meteo/Sentri
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v1.0 Initial commit of project

Browse Source
This commit is contained in:
Meteo
2026-01-01 10:54:18 +01:00
commit 768cf78b57
990 changed files with 241213 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

262
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Decoder/BitMatrixParser.php vendored Normal file
View File

@@ -0,0 +1,262 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Decoder;
use Zxing\Common\BitMatrix;
use Zxing\FormatException;
/**
* @author Sean Owen
*/
final class BitMatrixParser
{
private $bitMatrix;
/**
* @var mixed|null
*/
private $parsedVersion;
private $parsedFormatInfo;
private $mirror;
/**
* @param $bitMatrix {@link BitMatrix} to parse
*
* @throws FormatException if dimension is not >= 21 and 1 mod 4
*/
public function __construct($bitMatrix)
{
$dimension = $bitMatrix->getHeight();
if ($dimension < 21 || ($dimension & 0x03) != 1) {
throw FormatException::getFormatInstance();
}
$this->bitMatrix = $bitMatrix;
}
/**
* <p>Reads the bits in the {@link BitMatrix} representing the finder pattern in the
* correct order in order to reconstruct the codewords bytes contained within the
* QR Code.</p>
*
* @return bytes encoded within the QR Code
* @throws FormatException if the exact number of bytes expected is not read
*/
public function readCodewords()
{
$formatInfo = $this->readFormatInformation();
$version = $this->readVersion();
// Get the data mask for the format used in this QR Code. This will exclude
// some bits from reading as we wind through the bit matrix.
$dataMask = DataMask::forReference($formatInfo->getDataMask());
$dimension = $this->bitMatrix->getHeight();
$dataMask->unmaskBitMatrix($this->bitMatrix, $dimension);
$functionPattern = $version->buildFunctionPattern();
$readingUp = true;
if ($version->getTotalCodewords()) {
$result = fill_array(0, $version->getTotalCodewords(), 0);
} else {
$result = [];
}
$resultOffset = 0;
$currentByte = 0;
$bitsRead = 0;
// Read columns in pairs, from right to left
for ($j = $dimension - 1; $j > 0; $j -= 2) {
if ($j == 6) {
// Skip whole column with vertical alignment pattern;
// saves time and makes the other code proceed more cleanly
$j--;
}
// Read alternatingly from bottom to top then top to bottom
for ($count = 0; $count < $dimension; $count++) {
$i = $readingUp ? $dimension - 1 - $count : $count;
for ($col = 0; $col < 2; $col++) {
// Ignore bits covered by the function pattern
if (!$functionPattern->get($j - $col, $i)) {
// Read a bit
$bitsRead++;
$currentByte <<= 1;
if ($this->bitMatrix->get($j - $col, $i)) {
$currentByte |= 1;
}
// If we've made a whole byte, save it off
if ($bitsRead == 8) {
$result[$resultOffset++] = $currentByte; //(byte)
$bitsRead = 0;
$currentByte = 0;
}
}
}
}
$readingUp ^= true; // readingUp = !readingUp; // switch directions
}
if ($resultOffset != $version->getTotalCodewords()) {
throw FormatException::getFormatInstance();
}
return $result;
}
/**
* <p>Reads format information from one of its two locations within the QR Code.</p>
*
* @return {@link FormatInformation} encapsulating the QR Code's format info
* @throws FormatException if both format information locations cannot be parsed as
* the valid encoding of format information
*/
public function readFormatInformation()
{
if ($this->parsedFormatInfo != null) {
return $this->parsedFormatInfo;
}
// Read top-left format info bits
$formatInfoBits1 = 0;
for ($i = 0; $i < 6; $i++) {
$formatInfoBits1 = $this->copyBit($i, 8, $formatInfoBits1);
}
// .. and skip a bit in the timing pattern ...
$formatInfoBits1 = $this->copyBit(7, 8, $formatInfoBits1);
$formatInfoBits1 = $this->copyBit(8, 8, $formatInfoBits1);
$formatInfoBits1 = $this->copyBit(8, 7, $formatInfoBits1);
// .. and skip a bit in the timing pattern ...
for ($j = 5; $j >= 0; $j--) {
$formatInfoBits1 = $this->copyBit(8, $j, $formatInfoBits1);
}
// Read the top-right/bottom-left pattern too
$dimension = $this->bitMatrix->getHeight();
$formatInfoBits2 = 0;
$jMin = $dimension - 7;
for ($j = $dimension - 1; $j >= $jMin; $j--) {
$formatInfoBits2 = $this->copyBit(8, $j, $formatInfoBits2);
}
for ($i = $dimension - 8; $i < $dimension; $i++) {
$formatInfoBits2 = $this->copyBit($i, 8, $formatInfoBits2);
}
$parsedFormatInfo = FormatInformation::decodeFormatInformation($formatInfoBits1, $formatInfoBits2);
if ($parsedFormatInfo != null) {
return $parsedFormatInfo;
}
throw FormatException::getFormatInstance();
}
private function copyBit($i, $j, $versionBits)
{
$bit = $this->mirror ? $this->bitMatrix->get($j, $i) : $this->bitMatrix->get($i, $j);
return $bit ? ($versionBits << 1) | 0x1 : $versionBits << 1;
}
/**
* <p>Reads version information from one of its two locations within the QR Code.</p>
*
* @return {@link Version} encapsulating the QR Code's version
* @throws FormatException if both version information locations cannot be parsed as
* the valid encoding of version information
*/
public function readVersion()
{
if ($this->parsedVersion != null) {
return $this->parsedVersion;
}
$dimension = $this->bitMatrix->getHeight();
$provisionalVersion = ($dimension - 17) / 4;
if ($provisionalVersion <= 6) {
return Version::getVersionForNumber($provisionalVersion);
}
// Read top-right version info: 3 wide by 6 tall
$versionBits = 0;
$ijMin = $dimension - 11;
for ($j = 5; $j >= 0; $j--) {
for ($i = $dimension - 9; $i >= $ijMin; $i--) {
$versionBits = $this->copyBit($i, $j, $versionBits);
}
}
$theParsedVersion = Version::decodeVersionInformation($versionBits);
if ($theParsedVersion != null && $theParsedVersion->getDimensionForVersion() == $dimension) {
$this->parsedVersion = $theParsedVersion;
return $theParsedVersion;
}
// Hmm, failed. Try bottom left: 6 wide by 3 tall
$versionBits = 0;
for ($i = 5; $i >= 0; $i--) {
for ($j = $dimension - 9; $j >= $ijMin; $j--) {
$versionBits = $this->copyBit($i, $j, $versionBits);
}
}
$theParsedVersion = Version::decodeVersionInformation($versionBits);
if ($theParsedVersion != null && $theParsedVersion->getDimensionForVersion() == $dimension) {
$this->parsedVersion = $theParsedVersion;
return $theParsedVersion;
}
throw FormatException::getFormatInstance();
}
/**
* Revert the mask removal done while reading the code words. The bit matrix should revert to its original state.
*/
public function remask(): void
{
if ($this->parsedFormatInfo == null) {
return; // We have no format information, and have no data mask
}
$dataMask = DataMask::forReference($this->parsedFormatInfo->getDataMask());
$dimension = $this->bitMatrix->getHeight();
$dataMask->unmaskBitMatrix($this->bitMatrix, $dimension);
}
/**
* Prepare the parser for a mirrored operation.
* This flag has effect only on the {@link #readFormatInformation()} and the
* {@link #readVersion()}. Before proceeding with {@link #readCodewords()} the
* {@link #mirror()} method should be called.
*
* @param Whether $mirror to read version and format information mirrored.
*/
public function setMirror($mirror): void
{
$parsedVersion = null;
$parsedFormatInfo = null;
$this->mirror = $mirror;
}
/** Mirror the bit matrix in order to attempt a second reading. */
public function mirror(): void
{
for ($x = 0; $x < $this->bitMatrix->getWidth(); $x++) {
for ($y = $x + 1; $y < $this->bitMatrix->getHeight(); $y++) {
if ($this->bitMatrix->get($x, $y) != $this->bitMatrix->get($y, $x)) {
$this->bitMatrix->flip($y, $x);
$this->bitMatrix->flip($x, $y);
}
}
}
}
}

127
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Decoder/DataBlock.php vendored Normal file
View File

@@ -0,0 +1,127 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Decoder;
/**
* <p>Encapsulates a block of data within a QR Code. QR Codes may split their data into
* multiple blocks, each of which is a unit of data and error-correction codewords. Each
* is represented by an instance of this class.</p>
*
* @author Sean Owen
*/
final class DataBlock
{
//byte[]
private function __construct(private $numDataCodewords, private $codewords)
{
}
/**
* <p>When QR Codes use multiple data blocks, they are actually interleaved.
* That is, the first byte of data block 1 to n is written, then the second bytes, and so on. This
* method will separate the data into original blocks.</p>
*
* @param bytes $rawCodewords as read directly from the QR Code
* @param version $version of the QR Code
* @param error $ecLevel-correction level of the QR Code
*
* @return array DataBlocks containing original bytes, "de-interleaved" from representation in the
* QR Code
*/
public static function getDataBlocks(
$rawCodewords,
$version,
$ecLevel
)
{
if ((is_countable($rawCodewords) ? count($rawCodewords) : 0) != $version->getTotalCodewords()) {
throw new \InvalidArgumentException();
}
// Figure out the number and size of data blocks used by this version and
// error correction level
$ecBlocks = $version->getECBlocksForLevel($ecLevel);
// First count the total number of data blocks
$totalBlocks = 0;
$ecBlockArray = $ecBlocks->getECBlocks();
foreach ($ecBlockArray as $ecBlock) {
$totalBlocks += $ecBlock->getCount();
}
// Now establish DataBlocks of the appropriate size and number of data codewords
$result = [];//new DataBlock[$totalBlocks];
$numResultBlocks = 0;
foreach ($ecBlockArray as $ecBlock) {
$ecBlockCount = $ecBlock->getCount();
for ($i = 0; $i < $ecBlockCount; $i++) {
$numDataCodewords = $ecBlock->getDataCodewords();
$numBlockCodewords = $ecBlocks->getECCodewordsPerBlock() + $numDataCodewords;
$result[$numResultBlocks++] = new DataBlock($numDataCodewords, fill_array(0, $numBlockCodewords, 0));
}
}
// All blocks have the same amount of data, except that the last n
// (where n may be 0) have 1 more byte. Figure out where these start.
$shorterBlocksTotalCodewords = is_countable($result[0]->codewords) ? count($result[0]->codewords) : 0;
$longerBlocksStartAt = count($result) - 1;
while ($longerBlocksStartAt >= 0) {
$numCodewords = is_countable($result[$longerBlocksStartAt]->codewords) ? count($result[$longerBlocksStartAt]->codewords) : 0;
if ($numCodewords == $shorterBlocksTotalCodewords) {
break;
}
$longerBlocksStartAt--;
}
$longerBlocksStartAt++;
$shorterBlocksNumDataCodewords = $shorterBlocksTotalCodewords - $ecBlocks->getECCodewordsPerBlock();
// The last elements of result may be 1 element longer;
// first fill out as many elements as all of them have
$rawCodewordsOffset = 0;
for ($i = 0; $i < $shorterBlocksNumDataCodewords; $i++) {
for ($j = 0; $j < $numResultBlocks; $j++) {
$result[$j]->codewords[$i] = $rawCodewords[$rawCodewordsOffset++];
}
}
// Fill out the last data block in the longer ones
for ($j = $longerBlocksStartAt; $j < $numResultBlocks; $j++) {
$result[$j]->codewords[$shorterBlocksNumDataCodewords] = $rawCodewords[$rawCodewordsOffset++];
}
// Now add in error correction blocks
$max = is_countable($result[0]->codewords) ? count($result[0]->codewords) : 0;
for ($i = $shorterBlocksNumDataCodewords; $i < $max; $i++) {
for ($j = 0; $j < $numResultBlocks; $j++) {
$iOffset = $j < $longerBlocksStartAt ? $i : $i + 1;
$result[$j]->codewords[$iOffset] = $rawCodewords[$rawCodewordsOffset++];
}
}
return $result;
}
public function getNumDataCodewords()
{
return $this->numDataCodewords;
}
public function getCodewords()
{
return $this->codewords;
}
}

194
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Decoder/DataMask.php vendored Normal file
View File

@@ -0,0 +1,194 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Decoder;
use Zxing\Common\BitMatrix;
/**
* <p>Encapsulates data masks for the data bits in a QR code, per ISO 18004:2006 6.8. Implementations
* of this class can un-mask a raw BitMatrix. For simplicity, they will unmask the entire BitMatrix,
* including areas used for finder patterns, timing patterns, etc. These areas should be unused
* after the point they are unmasked anyway.</p>
*
* <p>Note that the diagram in section 6.8.1 is misleading since it indicates that i is column position
* and j is row position. In fact, as the text says, i is row position and j is column position.</p>
*
* @author Sean Owen
*/
abstract class DataMask
{
/**
* See ISO 18004:2006 6.8.1
*/
private static array $DATA_MASKS = [];
public function __construct()
{
}
public static function Init(): void
{
self::$DATA_MASKS = [
new DataMask000(),
new DataMask001(),
new DataMask010(),
new DataMask011(),
new DataMask100(),
new DataMask101(),
new DataMask110(),
new DataMask111(),
];
}
/**
* @param a $reference value between 0 and 7 indicating one of the eight possible
* data mask patterns a QR Code may use
*
* @return DataMask encapsulating the data mask pattern
*/
public static function forReference($reference)
{
if ($reference < 0 || $reference > 7) {
throw new \InvalidArgumentException();
}
return self::$DATA_MASKS[$reference];
}
/**
* <p>Implementations of this method reverse the data masking process applied to a QR Code and
* make its bits ready to read.</p>
*
* @param representation $bits of QR Code bits
* @param dimension $dimension of QR Code, represented by bits, being unmasked
*/
final public function unmaskBitMatrix($bits, $dimension): void
{
for ($i = 0; $i < $dimension; $i++) {
for ($j = 0; $j < $dimension; $j++) {
if ($this->isMasked($i, $j)) {
$bits->flip($j, $i);
}
}
}
}
abstract public function isMasked($i, $j);
}
DataMask::Init();
/**
* 000: mask bits for which (x + y) mod 2 == 0
*/
final class DataMask000 extends DataMask
{
// @Override
public function isMasked($i, $j)
{
return (($i + $j) & 0x01) == 0;
}
}
/**
* 001: mask bits for which x mod 2 == 0
*/
final class DataMask001 extends DataMask
{
//@Override
public function isMasked($i, $j)
{
return ($i & 0x01) == 0;
}
}
/**
* 010: mask bits for which y mod 3 == 0
*/
final class DataMask010 extends DataMask
{
//@Override
public function isMasked($i, $j)
{
return $j % 3 == 0;
}
}
/**
* 011: mask bits for which (x + y) mod 3 == 0
*/
final class DataMask011 extends DataMask
{
//@Override
public function isMasked($i, $j)
{
return ($i + $j) % 3 == 0;
}
}
/**
* 100: mask bits for which (x/2 + y/3) mod 2 == 0
*/
final class DataMask100 extends DataMask
{
//@Override
public function isMasked($i, $j)
{
return (int)(((int)($i / 2) + (int)($j / 3)) & 0x01) == 0;
}
}
/**
* 101: mask bits for which xy mod 2 + xy mod 3 == 0
*/
final class DataMask101 extends DataMask
{
//@Override
public function isMasked($i, $j)
{
$temp = $i * $j;
return ($temp & 0x01) + ($temp % 3) == 0;
}
}
/**
* 110: mask bits for which (xy mod 2 + xy mod 3) mod 2 == 0
*/
final class DataMask110 extends DataMask
{
//@Override
public function isMasked($i, $j)
{
$temp = $i * $j;
return ((($temp & 0x01) + ($temp % 3)) & 0x01) == 0;
}
}
/**
* 111: mask bits for which ((x+y)mod 2 + xy mod 3) mod 2 == 0
*/
final class DataMask111 extends DataMask
{
//@Override
public function isMasked($i, $j)
{
return (((($i + $j) & 0x01) + (($i * $j) % 3)) & 0x01) == 0;
}
}

364
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Decoder/DecodedBitStreamParser.php vendored Normal file
View File

@@ -0,0 +1,364 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Decoder;
use Zxing\Common\BitSource;
use Zxing\Common\CharacterSetECI;
use Zxing\Common\DecoderResult;
use Zxing\FormatException;
/**
* <p>QR Codes can encode text as bits in one of several modes, and can use multiple modes
* in one QR Code. This class decodes the bits back into text.</p>
*
* <p>See ISO 18004:2006, 6.4.3 - 6.4.7</p>
*
* @author Sean Owen
*/
final class DecodedBitStreamParser
{
/**
* See ISO 18004:2006, 6.4.4 Table 5
*/
private static array $ALPHANUMERIC_CHARS = [
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
' ', '$', '%', '*', '+', '-', '.', '/', ':',
];
private static int $GB2312_SUBSET = 1;
public static function decode(
$bytes,
$version,
$ecLevel,
$hints
): \Zxing\Common\DecoderResult
{
$bits = new BitSource($bytes);
$result = '';//new StringBuilder(50);
$byteSegments = [];
$symbolSequence = -1;
$parityData = -1;
try {
$currentCharacterSetECI = null;
$fc1InEffect = false;
$mode = '';
do {
// While still another segment to read...
if ($bits->available() < 4) {
// OK, assume we're done. Really, a TERMINATOR mode should have been recorded here
$mode = Mode::$TERMINATOR;
} else {
$mode = Mode::forBits($bits->readBits(4)); // mode is encoded by 4 bits
}
if ($mode != Mode::$TERMINATOR) {
if ($mode == Mode::$FNC1_FIRST_POSITION || $mode == Mode::$FNC1_SECOND_POSITION) {
// We do little with FNC1 except alter the parsed result a bit according to the spec
$fc1InEffect = true;
} elseif ($mode == Mode::$STRUCTURED_APPEND) {
if ($bits->available() < 16) {
throw FormatException::getFormatInstance();
}
// sequence number and parity is added later to the result metadata
// Read next 8 bits (symbol sequence #) and 8 bits (parity data), then continue
$symbolSequence = $bits->readBits(8);
$parityData = $bits->readBits(8);
} elseif ($mode == Mode::$ECI) {
// Count doesn't apply to ECI
$value = self::parseECIValue($bits);
$currentCharacterSetECI = CharacterSetECI::getCharacterSetECIByValue($value);
if ($currentCharacterSetECI == null) {
throw FormatException::getFormatInstance();
}
} else {
// First handle Hanzi mode which does not start with character count
if ($mode == Mode::$HANZI) {
//chinese mode contains a sub set indicator right after mode indicator
$subset = $bits->readBits(4);
$countHanzi = $bits->readBits($mode->getCharacterCountBits($version));
if ($subset == self::$GB2312_SUBSET) {
self::decodeHanziSegment($bits, $result, $countHanzi);
}
} else {
// "Normal" QR code modes:
// How many characters will follow, encoded in this mode?
$count = $bits->readBits($mode->getCharacterCountBits($version));
if ($mode == Mode::$NUMERIC) {
self::decodeNumericSegment($bits, $result, $count);
} elseif ($mode == Mode::$ALPHANUMERIC) {
self::decodeAlphanumericSegment($bits, $result, $count, $fc1InEffect);
} elseif ($mode == Mode::$BYTE) {
self::decodeByteSegment($bits, $result, $count, $currentCharacterSetECI, $byteSegments, $hints);
} elseif ($mode == Mode::$KANJI) {
self::decodeKanjiSegment($bits, $result, $count);
} else {
throw FormatException::getFormatInstance();
}
}
}
}
} while ($mode != Mode::$TERMINATOR);
} catch (\InvalidArgumentException) {
// from readBits() calls
throw FormatException::getFormatInstance();
}
return new DecoderResult(
$bytes,
$result,
empty($byteSegments) ? null : $byteSegments,
$ecLevel == null ? null : 'L',//ErrorCorrectionLevel::toString($ecLevel),
$symbolSequence,
$parityData
);
}
private static function parseECIValue($bits)
{
$firstByte = $bits->readBits(8);
if (($firstByte & 0x80) == 0) {
// just one byte
return $firstByte & 0x7F;
}
if (($firstByte & 0xC0) == 0x80) {
// two bytes
$secondByte = $bits->readBits(8);
return (($firstByte & 0x3F) << 8) | $secondByte;
}
if (($firstByte & 0xE0) == 0xC0) {
// three bytes
$secondThirdBytes = $bits->readBits(16);
return (($firstByte & 0x1F) << 16) | $secondThirdBytes;
}
throw FormatException::getFormatInstance();
}
/**
* See specification GBT 18284-2000
*/
private static function decodeHanziSegment(
$bits,
&$result,
$count
)
{
// Don't crash trying to read more bits than we have available.
if ($count * 13 > $bits->available()) {
throw FormatException::getFormatInstance();
}
// Each character will require 2 bytes. Read the characters as 2-byte pairs
// and decode as GB2312 afterwards
$buffer = fill_array(0, 2 * $count, 0);
$offset = 0;
while ($count > 0) {
// Each 13 bits encodes a 2-byte character
$twoBytes = $bits->readBits(13);
$assembledTwoBytes = (($twoBytes / 0x060) << 8) | ($twoBytes % 0x060);
if ($assembledTwoBytes < 0x003BF) {
// In the 0xA1A1 to 0xAAFE range
$assembledTwoBytes += 0x0A1A1;
} else {
// In the 0xB0A1 to 0xFAFE range
$assembledTwoBytes += 0x0A6A1;
}
$buffer[$offset] = (($assembledTwoBytes >> 8) & 0xFF);//(byte)
$buffer[$offset + 1] = ($assembledTwoBytes & 0xFF);//(byte)
$offset += 2;
$count--;
}
$result .= iconv('GB2312', 'UTF-8', implode($buffer));
}
private static function decodeNumericSegment(
$bits,
&$result,
$count
)
{
// Read three digits at a time
while ($count >= 3) {
// Each 10 bits encodes three digits
if ($bits->available() < 10) {
throw FormatException::getFormatInstance();
}
$threeDigitsBits = $bits->readBits(10);
if ($threeDigitsBits >= 1000) {
throw FormatException::getFormatInstance();
}
$result .= (self::toAlphaNumericChar($threeDigitsBits / 100));
$result .= (self::toAlphaNumericChar(($threeDigitsBits / 10) % 10));
$result .= (self::toAlphaNumericChar($threeDigitsBits % 10));
$count -= 3;
}
if ($count == 2) {
// Two digits left over to read, encoded in 7 bits
if ($bits->available() < 7) {
throw FormatException::getFormatInstance();
}
$twoDigitsBits = $bits->readBits(7);
if ($twoDigitsBits >= 100) {
throw FormatException::getFormatInstance();
}
$result .= (self::toAlphaNumericChar($twoDigitsBits / 10));
$result .= (self::toAlphaNumericChar($twoDigitsBits % 10));
} elseif ($count == 1) {
// One digit left over to read
if ($bits->available() < 4) {
throw FormatException::getFormatInstance();
}
$digitBits = $bits->readBits(4);
if ($digitBits >= 10) {
throw FormatException::getFormatInstance();
}
$result .= (self::toAlphaNumericChar($digitBits));
}
}
private static function toAlphaNumericChar($value)
{
if ($value >= count(self::$ALPHANUMERIC_CHARS)) {
throw FormatException::getFormatInstance();
}
return self::$ALPHANUMERIC_CHARS[$value];
}
private static function decodeAlphanumericSegment(
$bits,
&$result,
$count,
$fc1InEffect
)
{
// Read two characters at a time
$start = strlen((string) $result);
while ($count > 1) {
if ($bits->available() < 11) {
throw FormatException::getFormatInstance();
}
$nextTwoCharsBits = $bits->readBits(11);
$result .= (self::toAlphaNumericChar($nextTwoCharsBits / 45));
$result .= (self::toAlphaNumericChar($nextTwoCharsBits % 45));
$count -= 2;
}
if ($count == 1) {
// special case: one character left
if ($bits->available() < 6) {
throw FormatException::getFormatInstance();
}
$result .= self::toAlphaNumericChar($bits->readBits(6));
}
// See section 6.4.8.1, 6.4.8.2
if ($fc1InEffect) {
// We need to massage the result a bit if in an FNC1 mode:
for ($i = $start; $i < strlen((string) $result); $i++) {
if ($result[$i] == '%') {
if ($i < strlen((string) $result) - 1 && $result[$i + 1] == '%') {
// %% is rendered as %
$result = substr_replace($result, '', $i + 1, 1);//deleteCharAt(i + 1);
} else {
// In alpha mode, % should be converted to FNC1 separator 0x1D
$result . setCharAt($i, chr(0x1D));
}
}
}
}
}
private static function decodeByteSegment(
$bits,
&$result,
$count,
$currentCharacterSetECI,
&$byteSegments,
$hints
)
{
// Don't crash trying to read more bits than we have available.
if (8 * $count > $bits->available()) {
throw FormatException::getFormatInstance();
}
$readBytes = fill_array(0, $count, 0);
for ($i = 0; $i < $count; $i++) {
$readBytes[$i] = $bits->readBits(8);//(byte)
}
$text = implode(array_map('chr', $readBytes));
$encoding = '';
if ($currentCharacterSetECI == null) {
// The spec isn't clear on this mode; see
// section 6.4.5: t does not say which encoding to assuming
// upon decoding. I have seen ISO-8859-1 used as well as
// Shift_JIS -- without anything like an ECI designator to
// give a hint.
$encoding = mb_detect_encoding($text, $hints);
} else {
$encoding = $currentCharacterSetECI->name();
}
// $result.= mb_convert_encoding($text ,$encoding);//(new String(readBytes, encoding));
$result .= $text;//(new String(readBytes, encoding));
$byteSegments = array_merge($byteSegments, $readBytes);
}
private static function decodeKanjiSegment(
$bits,
&$result,
$count
)
{
// Don't crash trying to read more bits than we have available.
if ($count * 13 > $bits->available()) {
throw FormatException::getFormatInstance();
}
// Each character will require 2 bytes. Read the characters as 2-byte pairs
// and decode as Shift_JIS afterwards
$buffer = [0, 2 * $count, 0];
$offset = 0;
while ($count > 0) {
// Each 13 bits encodes a 2-byte character
$twoBytes = $bits->readBits(13);
$assembledTwoBytes = (($twoBytes / 0x0C0) << 8) | ($twoBytes % 0x0C0);
if ($assembledTwoBytes < 0x01F00) {
// In the 0x8140 to 0x9FFC range
$assembledTwoBytes += 0x08140;
} else {
// In the 0xE040 to 0xEBBF range
$assembledTwoBytes += 0x0C140;
}
$buffer[$offset] = ($assembledTwoBytes >> 8);//(byte)
$buffer[$offset + 1] = $assembledTwoBytes; //(byte)
$offset += 2;
$count--;
}
// Shift_JIS may not be supported in some environments:
$result .= iconv('shift-jis', 'utf-8', implode($buffer));
}
private function DecodedBitStreamParser(): void
{
}
}

208
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Decoder/Decoder.php vendored Normal file
View File

@@ -0,0 +1,208 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Decoder;
use Zxing\ChecksumException;
use Zxing\Common\BitMatrix;
use Zxing\Common\Reedsolomon\GenericGF;
use Zxing\Common\Reedsolomon\ReedSolomonDecoder;
use Zxing\Common\Reedsolomon\ReedSolomonException;
use Zxing\FormatException;
/**
* <p>The main class which implements QR Code decoding -- as opposed to locating and extracting
* the QR Code from an image.</p>
*
* @author Sean Owen
*/
final class Decoder
{
private readonly \Zxing\Common\Reedsolomon\ReedSolomonDecoder $rsDecoder;
public function __construct()
{
$this->rsDecoder = new ReedSolomonDecoder(GenericGF::$QR_CODE_FIELD_256);
}
public function decode($variable, $hints = null)
{
if (is_array($variable)) {
return $this->decodeImage($variable, $hints);
} elseif ($variable instanceof BitMatrix) {
return $this->decodeBits($variable, $hints);
} elseif ($variable instanceof BitMatrixParser) {
return $this->decodeParser($variable, $hints);
}
die('decode error Decoder.php');
}
/**
* <p>Convenience method that can decode a QR Code represented as a 2D array of booleans.
* "true" is taken to mean a black module.</p>
*
* @param array $image booleans representing white/black QR Code modules
* @param decoding $hints hints that should be used to influence decoding
*
* @return text and bytes encoded within the QR Code
* @throws FormatException if the QR Code cannot be decoded
* @throws ChecksumException if error correction fails
*/
public function decodeImage($image, $hints = null)
{
$dimension = count($image);
$bits = new BitMatrix($dimension);
for ($i = 0; $i < $dimension; $i++) {
for ($j = 0; $j < $dimension; $j++) {
if ($image[$i][$j]) {
$bits->set($j, $i);
}
}
}
return $this->decode($bits, $hints);
}
/**
* <p>Decodes a QR Code represented as a {@link BitMatrix}. A 1 or "true" is taken to mean a black module.</p>
*
* @param BitMatrix $bits booleans representing white/black QR Code modules
* @param decoding $hints hints that should be used to influence decoding
*
* @return text and bytes encoded within the QR Code
* @throws FormatException if the QR Code cannot be decoded
* @throws ChecksumException if error correction fails
*/
public function decodeBits($bits, $hints = null)
{
// Construct a parser and read version, error-correction level
$parser = new BitMatrixParser($bits);
$fe = null;
$ce = null;
try {
return $this->decode($parser, $hints);
} catch (FormatException $e) {
$fe = $e;
} catch (ChecksumException $e) {
$ce = $e;
}
try {
// Revert the bit matrix
$parser->remask();
// Will be attempting a mirrored reading of the version and format info.
$parser->setMirror(true);
// Preemptively read the version.
$parser->readVersion();
// Preemptively read the format information.
$parser->readFormatInformation();
/*
* Since we're here, this means we have successfully detected some kind
* of version and format information when mirrored. This is a good sign,
* that the QR code may be mirrored, and we should try once more with a
* mirrored content.
*/
// Prepare for a mirrored reading.
$parser->mirror();
$result = $this->decode($parser, $hints);
// Success! Notify the caller that the code was mirrored.
$result->setOther(new QRCodeDecoderMetaData(true));
return $result;
} catch (FormatException $e) {// catch (FormatException | ChecksumException e) {
// Throw the exception from the original reading
if ($fe != null) {
throw $fe;
}
if ($ce != null) {
throw $ce;
}
throw $e;
}
}
private function decodeParser($parser, $hints = null)
{
$version = $parser->readVersion();
$ecLevel = $parser->readFormatInformation()->getErrorCorrectionLevel();
// Read codewords
$codewords = $parser->readCodewords();
// Separate into data blocks
$dataBlocks = DataBlock::getDataBlocks($codewords, $version, $ecLevel);
// Count total number of data bytes
$totalBytes = 0;
foreach ($dataBlocks as $dataBlock) {
$totalBytes += $dataBlock->getNumDataCodewords();
}
$resultBytes = fill_array(0, $totalBytes, 0);
$resultOffset = 0;
// Error-correct and copy data blocks together into a stream of bytes
foreach ($dataBlocks as $dataBlock) {
$codewordBytes = $dataBlock->getCodewords();
$numDataCodewords = $dataBlock->getNumDataCodewords();
$this->correctErrors($codewordBytes, $numDataCodewords);
for ($i = 0; $i < $numDataCodewords; $i++) {
$resultBytes[$resultOffset++] = $codewordBytes[$i];
}
}
// Decode the contents of that stream of bytes
return DecodedBitStreamParser::decode($resultBytes, $version, $ecLevel, $hints);
}
/**
* <p>Given data and error-correction codewords received, possibly corrupted by errors, attempts to
* correct the errors in-place using Reed-Solomon error correction.</p>
*
* @param data $codewordBytes and error correction codewords
* @param number $numDataCodewords of codewords that are data bytes
*
* @throws ChecksumException if error correction fails
*/
private function correctErrors(&$codewordBytes, $numDataCodewords)
{
$numCodewords = is_countable($codewordBytes) ? count($codewordBytes) : 0;
// First read into an array of ints
$codewordsInts = fill_array(0, $numCodewords, 0);
for ($i = 0; $i < $numCodewords; $i++) {
$codewordsInts[$i] = $codewordBytes[$i] & 0xFF;
}
$numECCodewords = (is_countable($codewordBytes) ? count($codewordBytes) : 0) - $numDataCodewords;
try {
$this->rsDecoder->decode($codewordsInts, $numECCodewords);
} catch (ReedSolomonException) {
throw ChecksumException::getChecksumInstance();
}
// Copy back into array of bytes -- only need to worry about the bytes that were data
// We don't care about errors in the error-correction codewords
for ($i = 0; $i < $numDataCodewords; $i++) {
$codewordBytes[$i] = $codewordsInts[$i];
}
}
}

90
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Decoder/ErrorCorrectionLevel.php vendored Normal file
View File

@@ -0,0 +1,90 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Decoder;
/**
* <p>See ISO 18004:2006, 6.5.1. This enum encapsulates the four error correction levels
* defined by the QR code standard.</p>
*
* @author Sean Owen
*/
class ErrorCorrectionLevel
{
/**
* @var \Zxing\Qrcode\Decoder\ErrorCorrectionLevel[]|null
*/
private static ?array $FOR_BITS = null;
public function __construct(private $bits, private $ordinal = 0)
{
}
public static function Init(): void
{
self::$FOR_BITS = [
new ErrorCorrectionLevel(0x00, 1), //M
new ErrorCorrectionLevel(0x01, 0), //L
new ErrorCorrectionLevel(0x02, 3), //H
new ErrorCorrectionLevel(0x03, 2), //Q
];
}
/** L = ~7% correction */
// self::$L = new ErrorCorrectionLevel(0x01);
/** M = ~15% correction */
//self::$M = new ErrorCorrectionLevel(0x00);
/** Q = ~25% correction */
//self::$Q = new ErrorCorrectionLevel(0x03);
/** H = ~30% correction */
//self::$H = new ErrorCorrectionLevel(0x02);
/**
* @param int $bits containing the two bits encoding a QR Code's error correction level
*
* @return ErrorCorrectionLevel representing the encoded error correction level
*/
public static function forBits($bits)
{
if ($bits < 0 || $bits >= (is_countable(self::$FOR_BITS) ? count(self::$FOR_BITS) : 0)) {
throw new \InvalidArgumentException();
}
$level = self::$FOR_BITS[$bits];
// $lev = self::$$bit;
return $level;
}
public function getBits()
{
return $this->bits;
}
public function toString()
{
return $this->bits;
}
public function getOrdinal()
{
return $this->ordinal;
}
}
ErrorCorrectionLevel::Init();

193
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Decoder/FormatInformation.php vendored Normal file
View File

@@ -0,0 +1,193 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Decoder;
/**
* <p>Encapsulates a QR Code's format information, including the data mask used and
* error correction level.</p>
*
* @author Sean Owen
* @see DataMask
* @see ErrorCorrectionLevel
*/
final class FormatInformation
{
public static $FORMAT_INFO_MASK_QR;
/**
* See ISO 18004:2006, Annex C, Table C.1
*/
public static $FORMAT_INFO_DECODE_LOOKUP;
/**
* Offset i holds the number of 1 bits in the binary representation of i
* @var int[]|null
*/
private static ?array $BITS_SET_IN_HALF_BYTE = null;
private readonly \Zxing\Qrcode\Decoder\ErrorCorrectionLevel $errorCorrectionLevel;
private readonly int $dataMask;
private function __construct($formatInfo)
{
// Bits 3,4
$this->errorCorrectionLevel = ErrorCorrectionLevel::forBits(($formatInfo >> 3) & 0x03);
// Bottom 3 bits
$this->dataMask = ($formatInfo & 0x07);//(byte)
}
public static function Init(): void
{
self::$FORMAT_INFO_MASK_QR = 0x5412;
self::$BITS_SET_IN_HALF_BYTE = [0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4];
self::$FORMAT_INFO_DECODE_LOOKUP = [
[0x5412, 0x00],
[0x5125, 0x01],
[0x5E7C, 0x02],
[0x5B4B, 0x03],
[0x45F9, 0x04],
[0x40CE, 0x05],
[0x4F97, 0x06],
[0x4AA0, 0x07],
[0x77C4, 0x08],
[0x72F3, 0x09],
[0x7DAA, 0x0A],
[0x789D, 0x0B],
[0x662F, 0x0C],
[0x6318, 0x0D],
[0x6C41, 0x0E],
[0x6976, 0x0F],
[0x1689, 0x10],
[0x13BE, 0x11],
[0x1CE7, 0x12],
[0x19D0, 0x13],
[0x0762, 0x14],
[0x0255, 0x15],
[0x0D0C, 0x16],
[0x083B, 0x17],
[0x355F, 0x18],
[0x3068, 0x19],
[0x3F31, 0x1A],
[0x3A06, 0x1B],
[0x24B4, 0x1C],
[0x2183, 0x1D],
[0x2EDA, 0x1E],
[0x2BED, 0x1F],
];
}
/**
* @param $maskedFormatInfo1 ; format info indicator, with mask still applied
* @param $maskedFormatInfo2 ; second copy of same info; both are checked at the same time
* to establish best match
*
* @return information about the format it specifies, or {@code null}
* if doesn't seem to match any known pattern
*/
public static function decodeFormatInformation($maskedFormatInfo1, $maskedFormatInfo2)
{
$formatInfo = self::doDecodeFormatInformation($maskedFormatInfo1, $maskedFormatInfo2);
if ($formatInfo != null) {
return $formatInfo;
}
// Should return null, but, some QR codes apparently
// do not mask this info. Try again by actually masking the pattern
// first
return self::doDecodeFormatInformation(
$maskedFormatInfo1 ^ self::$FORMAT_INFO_MASK_QR,
$maskedFormatInfo2 ^ self::$FORMAT_INFO_MASK_QR
);
}
private static function doDecodeFormatInformation($maskedFormatInfo1, $maskedFormatInfo2)
{
// Find the int in FORMAT_INFO_DECODE_LOOKUP with fewest bits differing
$bestDifference = PHP_INT_MAX;
$bestFormatInfo = 0;
foreach (self::$FORMAT_INFO_DECODE_LOOKUP as $decodeInfo) {
$targetInfo = $decodeInfo[0];
if ($targetInfo == $maskedFormatInfo1 || $targetInfo == $maskedFormatInfo2) {
// Found an exact match
return new FormatInformation($decodeInfo[1]);
}
$bitsDifference = self::numBitsDiffering($maskedFormatInfo1, $targetInfo);
if ($bitsDifference < $bestDifference) {
$bestFormatInfo = $decodeInfo[1];
$bestDifference = $bitsDifference;
}
if ($maskedFormatInfo1 != $maskedFormatInfo2) {
// also try the other option
$bitsDifference = self::numBitsDiffering($maskedFormatInfo2, $targetInfo);
if ($bitsDifference < $bestDifference) {
$bestFormatInfo = $decodeInfo[1];
$bestDifference = $bitsDifference;
}
}
}
// Hamming distance of the 32 masked codes is 7, by construction, so <= 3 bits
// differing means we found a match
if ($bestDifference <= 3) {
return new FormatInformation($bestFormatInfo);
}
return null;
}
public static function numBitsDiffering($a, $b)
{
$a ^= $b; // a now has a 1 bit exactly where its bit differs with b's
// Count bits set quickly with a series of lookups:
return self::$BITS_SET_IN_HALF_BYTE[$a & 0x0F] +
self::$BITS_SET_IN_HALF_BYTE[(int)(uRShift($a, 4) & 0x0F)] +
self::$BITS_SET_IN_HALF_BYTE[(uRShift($a, 8) & 0x0F)] +
self::$BITS_SET_IN_HALF_BYTE[(uRShift($a, 12) & 0x0F)] +
self::$BITS_SET_IN_HALF_BYTE[(uRShift($a, 16) & 0x0F)] +
self::$BITS_SET_IN_HALF_BYTE[(uRShift($a, 20) & 0x0F)] +
self::$BITS_SET_IN_HALF_BYTE[(uRShift($a, 24) & 0x0F)] +
self::$BITS_SET_IN_HALF_BYTE[(uRShift($a, 28) & 0x0F)];
}
public function getErrorCorrectionLevel()
{
return $this->errorCorrectionLevel;
}
public function getDataMask()
{
return $this->dataMask;
}
//@Override
public function hashCode()
{
return ($this->errorCorrectionLevel->ordinal() << 3) | (int)($this->dataMask);
}
//@Override
public function equals($o)
{
if (!($o instanceof FormatInformation)) {
return false;
}
$other = $o;
return $this->errorCorrectionLevel == $other->errorCorrectionLevel &&
$this->dataMask == $other->dataMask;
}
}
FormatInformation::Init();

108
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Decoder/Mode.php vendored Normal file
View File

@@ -0,0 +1,108 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Decoder;
/**
* <p>See ISO 18004:2006, 6.4.1, Tables 2 and 3. This enum encapsulates the various modes in which
* data can be encoded to bits in the QR code standard.</p>
*
* @author Sean Owen
*/
class Mode
{
public static $TERMINATOR;
public static $NUMERIC;
public static $ALPHANUMERIC;
public static $STRUCTURED_APPEND;
public static $BYTE;
public static $ECI;
public static $KANJI;
public static $FNC1_FIRST_POSITION;
public static $FNC1_SECOND_POSITION;
public static $HANZI;
public function __construct(private $characterCountBitsForVersions, private $bits)
{
}
public static function Init(): void
{
self::$TERMINATOR = new Mode([0, 0, 0], 0x00); // Not really a mode...
self::$NUMERIC = new Mode([10, 12, 14], 0x01);
self::$ALPHANUMERIC = new Mode([9, 11, 13], 0x02);
self::$STRUCTURED_APPEND = new Mode([0, 0, 0], 0x03); // Not supported
self::$BYTE = new Mode([8, 16, 16], 0x04);
self::$ECI = new Mode([0, 0, 0], 0x07); // character counts don't apply
self::$KANJI = new Mode([8, 10, 12], 0x08);
self::$FNC1_FIRST_POSITION = new Mode([0, 0, 0], 0x05);
self::$FNC1_SECOND_POSITION = new Mode([0, 0, 0], 0x09);
/** See GBT 18284-2000; "Hanzi" is a transliteration of this mode name. */
self::$HANZI = new Mode([8, 10, 12], 0x0D);
}
/**
* @param four $bits bits encoding a QR Code data mode
*
* @return Mode encoded by these bits
* @throws InvalidArgumentException if bits do not correspond to a known mode
*/
public static function forBits($bits)
{
return match ($bits) {
0x0 => self::$TERMINATOR,
0x1 => self::$NUMERIC,
0x2 => self::$ALPHANUMERIC,
0x3 => self::$STRUCTURED_APPEND,
0x4 => self::$BYTE,
0x5 => self::$FNC1_FIRST_POSITION,
0x7 => self::$ECI,
0x8 => self::$KANJI,
0x9 => self::$FNC1_SECOND_POSITION,
0xD => self::$HANZI,
default => throw new \InvalidArgumentException(),
};
}
/**
* @param version $version in question
*
* @return number of bits used, in this QR Code symbol {@link Version}, to encode the
* count of characters that will follow encoded in this Mode
*/
public function getCharacterCountBits($version)
{
$number = $version->getVersionNumber();
$offset = 0;
if ($number <= 9) {
$offset = 0;
} elseif ($number <= 26) {
$offset = 1;
} else {
$offset = 2;
}
return $this->characterCountBitsForVersions[$offset];
}
public function getBits()
{
return $this->bits;
}
}
Mode::Init();

19
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Decoder/QRCodeDecoderMetaData.php vendored Normal file
View File

@@ -0,0 +1,19 @@
<?php
namespace Zxing\Qrcode\Decoder;
class QRCodeDecoderMetaData
{
/**
* QRCodeDecoderMetaData constructor.
* @param bool $mirrored
*/
public function __construct(private $mirrored)
{
}
public function isMirrored()
{
return $this->mirrored;
}
}

715
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Decoder/Version.php vendored Normal file
View File

@@ -0,0 +1,715 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Decoder;
use Zxing\Common\BitMatrix;
use Zxing\FormatException;
/**
* See ISO 18004:2006 Annex D
*
* @author Sean Owen
*/
class Version
{
/**
* See ISO 18004:2006 Annex D.
* Element i represents the raw version bits that specify version i + 7
*/
private static array $VERSION_DECODE_INFO = [
0x07C94, 0x085BC, 0x09A99, 0x0A4D3, 0x0BBF6,
0x0C762, 0x0D847, 0x0E60D, 0x0F928, 0x10B78,
0x1145D, 0x12A17, 0x13532, 0x149A6, 0x15683,
0x168C9, 0x177EC, 0x18EC4, 0x191E1, 0x1AFAB,
0x1B08E, 0x1CC1A, 0x1D33F, 0x1ED75, 0x1F250,
0x209D5, 0x216F0, 0x228BA, 0x2379F, 0x24B0B,
0x2542E, 0x26A64, 0x27541, 0x28C69
];
/**
* @var mixed|null
*/
private static $VERSIONS;
private readonly float|int $totalCodewords;
public function __construct(
private $versionNumber,
private $alignmentPatternCenters,
private $ecBlocks
)
{$total = 0;
if (is_array($ecBlocks)) {
$ecCodewords = $ecBlocks[0]->getECCodewordsPerBlock();
$ecbArray = $ecBlocks[0]->getECBlocks();
} else {
$ecCodewords = $ecBlocks->getECCodewordsPerBlock();
$ecbArray = $ecBlocks->getECBlocks();
}
foreach ($ecbArray as $ecBlock) {
$total += $ecBlock->getCount() * ($ecBlock->getDataCodewords() + $ecCodewords);
}
$this->totalCodewords = $total;
}
public function getVersionNumber()
{
return $this->versionNumber;
}
public function getAlignmentPatternCenters()
{
return $this->alignmentPatternCenters;
}
public function getTotalCodewords()
{
return $this->totalCodewords;
}
public function getDimensionForVersion()
{
return 17 + 4 * $this->versionNumber;
}
public function getECBlocksForLevel($ecLevel)
{
return $this->ecBlocks[$ecLevel->getOrdinal()];
}
/**
* <p>Deduces version information purely from QR Code dimensions.</p>
*
* @param dimension $dimension in modules
* @return Version for a QR Code of that dimension
* @throws FormatException if dimension is not 1 mod 4
*/
public static function getProvisionalVersionForDimension($dimension)
{
if ($dimension % 4 != 1) {
throw FormatException::getFormatInstance();
}
try {
return self::getVersionForNumber(($dimension - 17) / 4);
} catch (\InvalidArgumentException) {
throw FormatException::getFormatInstance();
}
}
public static function getVersionForNumber($versionNumber)
{
if ($versionNumber < 1 || $versionNumber > 40) {
throw new \InvalidArgumentException();
}
if (!self::$VERSIONS) {
self::$VERSIONS = self::buildVersions();
}
return self::$VERSIONS[$versionNumber - 1];
}
public static function decodeVersionInformation($versionBits)
{
$bestDifference = PHP_INT_MAX;
$bestVersion = 0;
for ($i = 0; $i < count(self::$VERSION_DECODE_INFO); $i++) {
$targetVersion = self::$VERSION_DECODE_INFO[$i];
// Do the version info bits match exactly? done.
if ($targetVersion == $versionBits) {
return self::getVersionForNumber($i + 7);
}
// Otherwise see if this is the closest to a real version info bit string
// we have seen so far
$bitsDifference = FormatInformation::numBitsDiffering($versionBits, $targetVersion);
if ($bitsDifference < $bestDifference) {
$bestVersion = $i + 7;
$bestDifference = $bitsDifference;
}
}
// We can tolerate up to 3 bits of error since no two version info codewords will
// differ in less than 8 bits.
if ($bestDifference <= 3) {
return self::getVersionForNumber($bestVersion);
}
// If we didn't find a close enough match, fail
return null;
}
/**
* See ISO 18004:2006 Annex E
*/
public function buildFunctionPattern()
{
$dimension = self::getDimensionForVersion();
$bitMatrix = new BitMatrix($dimension);
// Top left finder pattern + separator + format
$bitMatrix->setRegion(0, 0, 9, 9);
// Top right finder pattern + separator + format
$bitMatrix->setRegion($dimension - 8, 0, 8, 9);
// Bottom left finder pattern + separator + format
$bitMatrix->setRegion(0, $dimension - 8, 9, 8);
// Alignment patterns
$max = is_countable($this->alignmentPatternCenters) ? count($this->alignmentPatternCenters) : 0;
for ($x = 0; $x < $max; $x++) {
$i = $this->alignmentPatternCenters[$x] - 2;
for ($y = 0; $y < $max; $y++) {
if (($x == 0 && ($y == 0 || $y == $max - 1)) || ($x == $max - 1 && $y == 0)) {
// No alignment patterns near the three finder paterns
continue;
}
$bitMatrix->setRegion($this->alignmentPatternCenters[$y] - 2, $i, 5, 5);
}
}
// Vertical timing pattern
$bitMatrix->setRegion(6, 9, 1, $dimension - 17);
// Horizontal timing pattern
$bitMatrix->setRegion(9, 6, $dimension - 17, 1);
if ($this->versionNumber > 6) {
// Version info, top right
$bitMatrix->setRegion($dimension - 11, 0, 3, 6);
// Version info, bottom left
$bitMatrix->setRegion(0, $dimension - 11, 6, 3);
}
return $bitMatrix;
}
/**
* See ISO 18004:2006 6.5.1 Table 9
*/
private static function buildVersions()
{
return [
new Version(
1,
[],
[new ECBlocks(7, [new ECB(1, 19)]),
new ECBlocks(10, [new ECB(1, 16)]),
new ECBlocks(13, [new ECB(1, 13)]),
new ECBlocks(17, [new ECB(1, 9)])]
),
new Version(
2,
[6, 18],
[new ECBlocks(10, [new ECB(1, 34)]),
new ECBlocks(16, [new ECB(1, 28)]),
new ECBlocks(22, [new ECB(1, 22)]),
new ECBlocks(28, [new ECB(1, 16)])]
),
new Version(
3,
[6, 22],
[ new ECBlocks(15, [new ECB(1, 55)]),
new ECBlocks(26, [new ECB(1, 44)]),
new ECBlocks(18, [new ECB(2, 17)]),
new ECBlocks(22, [new ECB(2, 13)])]
),
new Version(
4,
[6, 26],
[new ECBlocks(20, [new ECB(1, 80)]),
new ECBlocks(18, [new ECB(2, 32)]),
new ECBlocks(26, [new ECB(2, 24)]),
new ECBlocks(16, [new ECB(4, 9)])]
),
new Version(
5,
[6, 30],
[new ECBlocks(26, [new ECB(1, 108)]),
new ECBlocks(24, [new ECB(2, 43)]),
new ECBlocks(18, [new ECB(2, 15),
new ECB(2, 16)]),
new ECBlocks(22, [new ECB(2, 11),
new ECB(2, 12)])]
),
new Version(
6,
[6, 34],
[new ECBlocks(18, [new ECB(2, 68)]),
new ECBlocks(16, [new ECB(4, 27)]),
new ECBlocks(24, [new ECB(4, 19)]),
new ECBlocks(28, [new ECB(4, 15)])]
),
new Version(
7,
[6, 22, 38],
[new ECBlocks(20, [new ECB(2, 78)]),
new ECBlocks(18, [new ECB(4, 31)]),
new ECBlocks(18, [new ECB(2, 14),
new ECB(4, 15)]),
new ECBlocks(26, [new ECB(4, 13),
new ECB(1, 14)])]
),
new Version(
8,
[6, 24, 42],
[new ECBlocks(24, [new ECB(2, 97)]),
new ECBlocks(22, [new ECB(2, 38),
new ECB(2, 39)]),
new ECBlocks(22, [new ECB(4, 18),
new ECB(2, 19)]),
new ECBlocks(26, [new ECB(4, 14),
new ECB(2, 15)])]
),
new Version(
9,
[6, 26, 46],
[new ECBlocks(30, [new ECB(2, 116)]),
new ECBlocks(22, [new ECB(3, 36),
new ECB(2, 37)]),
new ECBlocks(20, [new ECB(4, 16),
new ECB(4, 17)]),
new ECBlocks(24, [new ECB(4, 12),
new ECB(4, 13)])]
),
new Version(
10,
[6, 28, 50],
[new ECBlocks(18, [new ECB(2, 68),
new ECB(2, 69)]),
new ECBlocks(26, [new ECB(4, 43),
new ECB(1, 44)]),
new ECBlocks(24, [new ECB(6, 19),
new ECB(2, 20)]),
new ECBlocks(28, [new ECB(6, 15),
new ECB(2, 16)])]
),
new Version(
11,
[6, 30, 54],
[new ECBlocks(20, [new ECB(4, 81)]),
new ECBlocks(30, [new ECB(1, 50),
new ECB(4, 51)]),
new ECBlocks(28, [new ECB(4, 22),
new ECB(4, 23)]),
new ECBlocks(24, [new ECB(3, 12),
new ECB(8, 13)])]
),
new Version(
12,
[6, 32, 58],
[new ECBlocks(24, [new ECB(2, 92),
new ECB(2, 93)]),
new ECBlocks(22, [new ECB(6, 36),
new ECB(2, 37)]),
new ECBlocks(26, [new ECB(4, 20),
new ECB(6, 21)]),
new ECBlocks(28, [new ECB(7, 14),
new ECB(4, 15)])]
),
new Version(
13,
[6, 34, 62],
[new ECBlocks(26, [new ECB(4, 107)]),
new ECBlocks(22, [new ECB(8, 37),
new ECB(1, 38)]),
new ECBlocks(24, [new ECB(8, 20),
new ECB(4, 21)]),
new ECBlocks(22, [new ECB(12, 11),
new ECB(4, 12)])]
),
new Version(
14,
[6, 26, 46, 66],
[new ECBlocks(30, [new ECB(3, 115),
new ECB(1, 116)]),
new ECBlocks(24, [new ECB(4, 40),
new ECB(5, 41)]),
new ECBlocks(20, [new ECB(11, 16),
new ECB(5, 17)]),
new ECBlocks(24, [new ECB(11, 12),
new ECB(5, 13)])]
),
new Version(
15,
[6, 26, 48, 70],
[new ECBlocks(22, [new ECB(5, 87),
new ECB(1, 88)]),
new ECBlocks(24, [new ECB(5, 41),
new ECB(5, 42)]),
new ECBlocks(30, [new ECB(5, 24),
new ECB(7, 25)]),
new ECBlocks(24, [new ECB(11, 12),
new ECB(7, 13)])]
),
new Version(
16,
[6, 26, 50, 74],
[new ECBlocks(24, [new ECB(5, 98),
new ECB(1, 99)]),
new ECBlocks(28, [new ECB(7, 45),
new ECB(3, 46)]),
new ECBlocks(24, [new ECB(15, 19),
new ECB(2, 20)]),
new ECBlocks(30, [new ECB(3, 15),
new ECB(13, 16)])]
),
new Version(
17,
[6, 30, 54, 78],
[new ECBlocks(28, [new ECB(1, 107),
new ECB(5, 108)]),
new ECBlocks(28, [new ECB(10, 46),
new ECB(1, 47)]),
new ECBlocks(28, [new ECB(1, 22),
new ECB(15, 23)]),
new ECBlocks(28, [new ECB(2, 14),
new ECB(17, 15)])]
),
new Version(
18,
[6, 30, 56, 82],
[new ECBlocks(30, [new ECB(5, 120),
new ECB(1, 121)]),
new ECBlocks(26, [new ECB(9, 43),
new ECB(4, 44)]),
new ECBlocks(28, [new ECB(17, 22),
new ECB(1, 23)]),
new ECBlocks(28, [new ECB(2, 14),
new ECB(19, 15)])]
),
new Version(
19,
[6, 30, 58, 86],
[new ECBlocks(28, [new ECB(3, 113),
new ECB(4, 114)]),
new ECBlocks(26, [new ECB(3, 44),
new ECB(11, 45)]),
new ECBlocks(26, [new ECB(17, 21),
new ECB(4, 22)]),
new ECBlocks(26, [new ECB(9, 13),
new ECB(16, 14)])]
),
new Version(
20,
[6, 34, 62, 90],
[new ECBlocks(28, [new ECB(3, 107),
new ECB(5, 108)]),
new ECBlocks(26, [new ECB(3, 41),
new ECB(13, 42)]),
new ECBlocks(30, [new ECB(15, 24),
new ECB(5, 25)]),
new ECBlocks(28, [new ECB(15, 15),
new ECB(10, 16)])]
),
new Version(
21,
[6, 28, 50, 72, 94],
[ new ECBlocks(28, [new ECB(4, 116),
new ECB(4, 117)]),
new ECBlocks(26, [new ECB(17, 42)]),
new ECBlocks(28, [new ECB(17, 22),
new ECB(6, 23)]),
new ECBlocks(30, [new ECB(19, 16),
new ECB(6, 17)])]
),
new Version(
22,
[6, 26, 50, 74, 98],
[new ECBlocks(28, [new ECB(2, 111),
new ECB(7, 112)]),
new ECBlocks(28, [new ECB(17, 46)]),
new ECBlocks(30, [new ECB(7, 24),
new ECB(16, 25)]),
new ECBlocks(24, [new ECB(34, 13)])]
),
new Version(
23,
[6, 30, 54, 78, 102],
new ECBlocks(30, [new ECB(4, 121),
new ECB(5, 122)]),
new ECBlocks(28, [new ECB(4, 47),
new ECB(14, 48)]),
new ECBlocks(30, [new ECB(11, 24),
new ECB(14, 25)]),
new ECBlocks(30, [new ECB(16, 15),
new ECB(14, 16)])
),
new Version(
24,
[6, 28, 54, 80, 106],
[new ECBlocks(30, [new ECB(6, 117),
new ECB(4, 118)]),
new ECBlocks(28, [new ECB(6, 45),
new ECB(14, 46)]),
new ECBlocks(30, [new ECB(11, 24),
new ECB(16, 25)]),
new ECBlocks(30, [new ECB(30, 16),
new ECB(2, 17)])]
),
new Version(
25,
[6, 32, 58, 84, 110],
[new ECBlocks(26, [new ECB(8, 106),
new ECB(4, 107)]),
new ECBlocks(28, [new ECB(8, 47),
new ECB(13, 48)]),
new ECBlocks(30, [new ECB(7, 24),
new ECB(22, 25)]),
new ECBlocks(30, [new ECB(22, 15),
new ECB(13, 16)])]
),
new Version(
26,
[6, 30, 58, 86, 114],
[new ECBlocks(28, [new ECB(10, 114),
new ECB(2, 115)]),
new ECBlocks(28, [new ECB(19, 46),
new ECB(4, 47)]),
new ECBlocks(28, [new ECB(28, 22),
new ECB(6, 23)]),
new ECBlocks(30, [new ECB(33, 16),
new ECB(4, 17)])]
),
new Version(
27,
[6, 34, 62, 90, 118],
[new ECBlocks(30, [new ECB(8, 122),
new ECB(4, 123)]),
new ECBlocks(28, [new ECB(22, 45),
new ECB(3, 46)]),
new ECBlocks(30, [new ECB(8, 23),
new ECB(26, 24)]),
new ECBlocks(30, [new ECB(12, 15),
new ECB(28, 16)])]
),
new Version(
28,
[6, 26, 50, 74, 98, 122],
[new ECBlocks(30, [new ECB(3, 117),
new ECB(10, 118)]),
new ECBlocks(28, [new ECB(3, 45),
new ECB(23, 46)]),
new ECBlocks(30, [new ECB(4, 24),
new ECB(31, 25)]),
new ECBlocks(30, [new ECB(11, 15),
new ECB(31, 16)])]
),
new Version(
29,
[6, 30, 54, 78, 102, 126],
[new ECBlocks(30, [new ECB(7, 116),
new ECB(7, 117)]),
new ECBlocks(28, [new ECB(21, 45),
new ECB(7, 46)]),
new ECBlocks(30, [new ECB(1, 23),
new ECB(37, 24)]),
new ECBlocks(30, [new ECB(19, 15),
new ECB(26, 16)])]
),
new Version(
30,
[6, 26, 52, 78, 104, 130],
[new ECBlocks(30, [new ECB(5, 115),
new ECB(10, 116)]),
new ECBlocks(28, [new ECB(19, 47),
new ECB(10, 48)]),
new ECBlocks(30, [new ECB(15, 24),
new ECB(25, 25)]),
new ECBlocks(30, [new ECB(23, 15),
new ECB(25, 16)])]
),
new Version(
31,
[6, 30, 56, 82, 108, 134],
[new ECBlocks(30, [new ECB(13, 115),
new ECB(3, 116)]),
new ECBlocks(28, [new ECB(2, 46),
new ECB(29, 47)]),
new ECBlocks(30, [new ECB(42, 24),
new ECB(1, 25)]),
new ECBlocks(30, [new ECB(23, 15),
new ECB(28, 16)])]
),
new Version(
32,
[6, 34, 60, 86, 112, 138],
[new ECBlocks(30, [new ECB(17, 115)]),
new ECBlocks(28, [new ECB(10, 46),
new ECB(23, 47)]),
new ECBlocks(30, [new ECB(10, 24),
new ECB(35, 25)]),
new ECBlocks(30, [new ECB(19, 15),
new ECB(35, 16)])]
),
new Version(
33,
[6, 30, 58, 86, 114, 142],
[new ECBlocks(30, [new ECB(17, 115),
new ECB(1, 116)]),
new ECBlocks(28, [new ECB(14, 46),
new ECB(21, 47)]),
new ECBlocks(30, [new ECB(29, 24),
new ECB(19, 25)]),
new ECBlocks(30, [new ECB(11, 15),
new ECB(46, 16)])]
),
new Version(
34,
[6, 34, 62, 90, 118, 146],
[new ECBlocks(30, [new ECB(13, 115),
new ECB(6, 116)]),
new ECBlocks(28, [new ECB(14, 46),
new ECB(23, 47)]),
new ECBlocks(30, [new ECB(44, 24),
new ECB(7, 25)]),
new ECBlocks(30, [new ECB(59, 16),
new ECB(1, 17)])]
),
new Version(
35,
[6, 30, 54, 78, 102, 126, 150],
[new ECBlocks(30, [new ECB(12, 121),
new ECB(7, 122)]),
new ECBlocks(28, [new ECB(12, 47),
new ECB(26, 48)]),
new ECBlocks(30, [new ECB(39, 24),
new ECB(14, 25)]),
new ECBlocks(30, [new ECB(22, 15),
new ECB(41, 16)])]
),
new Version(
36,
[6, 24, 50, 76, 102, 128, 154],
[new ECBlocks(30, [new ECB(6, 121),
new ECB(14, 122)]),
new ECBlocks(28, [new ECB(6, 47),
new ECB(34, 48)]),
new ECBlocks(30, [new ECB(46, 24),
new ECB(10, 25)]),
new ECBlocks(30, [new ECB(2, 15),
new ECB(64, 16)])]
),
new Version(
37,
[6, 28, 54, 80, 106, 132, 158],
[new ECBlocks(30, [new ECB(17, 122),
new ECB(4, 123)]),
new ECBlocks(28, [new ECB(29, 46),
new ECB(14, 47)]),
new ECBlocks(30, [new ECB(49, 24),
new ECB(10, 25)]),
new ECBlocks(30, [new ECB(24, 15),
new ECB(46, 16)])]
),
new Version(
38,
[6, 32, 58, 84, 110, 136, 162],
[new ECBlocks(30, [new ECB(4, 122),
new ECB(18, 123)]),
new ECBlocks(28, [new ECB(13, 46),
new ECB(32, 47)]),
new ECBlocks(30, [new ECB(48, 24),
new ECB(14, 25)]),
new ECBlocks(30, [new ECB(42, 15),
new ECB(32, 16)])]
),
new Version(
39,
[6, 26, 54, 82, 110, 138, 166],
[new ECBlocks(30, [new ECB(20, 117),
new ECB(4, 118)]),
new ECBlocks(28, [new ECB(40, 47),
new ECB(7, 48)]),
new ECBlocks(30, [new ECB(43, 24),
new ECB(22, 25)]),
new ECBlocks(30, [new ECB(10, 15),
new ECB(67, 16)])]
),
new Version(
40,
[6, 30, 58, 86, 114, 142, 170],
[new ECBlocks(30, [new ECB(19, 118),
new ECB(6, 119)]),
new ECBlocks(28, [new ECB(18, 47),
new ECB(31, 48)]),
new ECBlocks(30, [new ECB(34, 24),
new ECB(34, 25)]),
new ECBlocks(30, [new ECB(20, 15),
new ECB(61, 16)])]
)
];
}
}
/**
* <p>Encapsulates a set of error-correction blocks in one symbol version. Most versions will
* use blocks of differing sizes within one version, so, this encapsulates the parameters for
* each set of blocks. It also holds the number of error-correction codewords per block since it
* will be the same across all blocks within one version.</p>
*/
final class ECBlocks
{
public function __construct(private $ecCodewordsPerBlock, private $ecBlocks)
{
}
public function getECCodewordsPerBlock()
{
return $this->ecCodewordsPerBlock;
}
public function getNumBlocks()
{
$total = 0;
foreach ($this->ecBlocks as $ecBlock) {
$total += $ecBlock->getCount();
}
return $total;
}
public function getTotalECCodewords()
{
return $this->ecCodewordsPerBlock * $this->getNumBlocks();
}
public function getECBlocks()
{
return $this->ecBlocks;
}
}
/**
* <p>Encapsualtes the parameters for one error-correction block in one symbol version.
* This includes the number of data codewords, and the number of times a block with these
* parameters is used consecutively in the QR code version's format.</p>
*/
final class ECB
{
public function __construct(private $count, private $dataCodewords)
{
}
public function getCount()
{
return $this->count;
}
public function getDataCodewords()
{
return $this->dataCodewords;
}
//@Override
public function toString(): never
{
die('Version ECB toString()');
// return parent::$versionNumber;
}
}

62
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Detector/AlignmentPattern.php vendored Normal file
View File

@@ -0,0 +1,62 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Detector;
use Zxing\ResultPoint;
/**
* <p>Encapsulates an alignment pattern, which are the smaller square patterns found in
* all but the simplest QR Codes.</p>
*
* @author Sean Owen
*/
final class AlignmentPattern extends ResultPoint
{
public function __construct($posX, $posY, private $estimatedModuleSize)
{
parent::__construct($posX, $posY);
}
/**
* <p>Determines if this alignment pattern "about equals" an alignment pattern at the stated
* position and size -- meaning, it is at nearly the same center with nearly the same size.</p>
*/
public function aboutEquals($moduleSize, $i, $j)
{
if (abs($i - $this->getY()) <= $moduleSize && abs($j - $this->getX()) <= $moduleSize) {
$moduleSizeDiff = abs($moduleSize - $this->estimatedModuleSize);
return $moduleSizeDiff <= 1.0 || $moduleSizeDiff <= $this->estimatedModuleSize;
}
return false;
}
/**
* Combines this object's current estimate of a finder pattern position and module size
* with a new estimate. It returns a new {@code FinderPattern} containing an average of the two.
*/
public function combineEstimate($i, $j, $newModuleSize): \Zxing\Qrcode\Detector\AlignmentPattern
{
$combinedX = ($this->getX() + $j) / 2.0;
$combinedY = ($this->getY() + $i) / 2.0;
$combinedModuleSize = ($this->estimatedModuleSize + $newModuleSize) / 2.0;
return new AlignmentPattern($combinedX, $combinedY, $combinedModuleSize);
}
}

265
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Detector/AlignmentPatternFinder.php vendored Normal file
View File

@@ -0,0 +1,265 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Detector;
use Zxing\NotFoundException;
/**
* <p>This class attempts to find alignment patterns in a QR Code. Alignment patterns look like finder
* patterns but are smaller and appear at regular intervals throughout the image.</p>
*
* <p>At the moment this only looks for the bottom-right alignment pattern.</p>
*
* <p>This is mostly a simplified copy of {@link FinderPatternFinder}. It is copied,
* pasted and stripped down here for maximum performance but does unfortunately duplicate
* some code.</p>
*
* <p>This class is thread-safe but not reentrant. Each thread must allocate its own object.</p>
*
* @author Sean Owen
*/
final class AlignmentPatternFinder
{
private array $possibleCenters = [];
private array $crossCheckStateCount = [];
/**
* <p>Creates a finder that will look in a portion of the whole image.</p>
*
* @param \Imagick image $image to search
* @param int left $startX column from which to start searching
* @param int top $startY row from which to start searching
* @param float width $width of region to search
* @param float height $height of region to search
* @param float estimated $moduleSize module size so far
*/
public function __construct(private $image, private $startX, private $startY, private $width, private $height, private $moduleSize, private $resultPointCallback)
{
}
/**
* <p>This method attempts to find the bottom-right alignment pattern in the image. It is a bit messy since
* it's pretty performance-critical and so is written to be fast foremost.</p>
*
* @return {@link AlignmentPattern} if found
* @throws NotFoundException if not found
*/
public function find()
{
$startX = $this->startX;
$height = $this->height;
$maxJ = $startX + $this->width;
$middleI = $this->startY + ($height / 2);
// We are looking for black/white/black modules in 1:1:1 ratio;
// this tracks the number of black/white/black modules seen so far
$stateCount = [];
for ($iGen = 0; $iGen < $height; $iGen++) {
// Search from middle outwards
$i = $middleI + (($iGen & 0x01) == 0 ? ($iGen + 1) / 2 : -(($iGen + 1) / 2));
$i = (int)($i);
$stateCount[0] = 0;
$stateCount[1] = 0;
$stateCount[2] = 0;
$j = $startX;
// Burn off leading white pixels before anything else; if we start in the middle of
// a white run, it doesn't make sense to count its length, since we don't know if the
// white run continued to the left of the start point
while ($j < $maxJ && !$this->image->get($j, $i)) {
$j++;
}
$currentState = 0;
while ($j < $maxJ) {
if ($this->image->get($j, $i)) {
// Black pixel
if ($currentState == 1) { // Counting black pixels
$stateCount[$currentState]++;
} else { // Counting white pixels
if ($currentState == 2) { // A winner?
if ($this->foundPatternCross($stateCount)) { // Yes
$confirmed = $this->handlePossibleCenter($stateCount, $i, $j);
if ($confirmed != null) {
return $confirmed;
}
}
$stateCount[0] = $stateCount[2];
$stateCount[1] = 1;
$stateCount[2] = 0;
$currentState = 1;
} else {
$stateCount[++$currentState]++;
}
}
} else { // White pixel
if ($currentState == 1) { // Counting black pixels
$currentState++;
}
$stateCount[$currentState]++;
}
$j++;
}
if ($this->foundPatternCross($stateCount)) {
$confirmed = $this->handlePossibleCenter($stateCount, $i, $maxJ);
if ($confirmed != null) {
return $confirmed;
}
}
}
// Hmm, nothing we saw was observed and confirmed twice. If we had
// any guess at all, return it.
if (count($this->possibleCenters)) {
return $this->possibleCenters[0];
}
throw NotFoundException::getNotFoundInstance();
}
/**
* @param count $stateCount of black/white/black pixels just read
*
* @return true iff the proportions of the counts is close enough to the 1/1/1 ratios
* used by alignment patterns to be considered a match
*/
private function foundPatternCross($stateCount)
{
$moduleSize = $this->moduleSize;
$maxVariance = $moduleSize / 2.0;
for ($i = 0; $i < 3; $i++) {
if (abs($moduleSize - $stateCount[$i]) >= $maxVariance) {
return false;
}
}
return true;
}
/**
* <p>This is called when a horizontal scan finds a possible alignment pattern. It will
* cross check with a vertical scan, and if successful, will see if this pattern had been
* found on a previous horizontal scan. If so, we consider it confirmed and conclude we have
* found the alignment pattern.</p>
*
* @param reading $stateCount state module counts from horizontal scan
* @param row $i where alignment pattern may be found
* @param end $j of possible alignment pattern in row
*
* @return {@link AlignmentPattern} if we have found the same pattern twice, or null if not
*/
private function handlePossibleCenter($stateCount, $i, $j)
{
$stateCountTotal = $stateCount[0] + $stateCount[1] + $stateCount[2];
$centerJ = self::centerFromEnd($stateCount, $j);
$centerI = $this->crossCheckVertical($i, (int)$centerJ, 2 * $stateCount[1], $stateCountTotal);
if (!is_nan($centerI)) {
$estimatedModuleSize = (float)($stateCount[0] + $stateCount[1] + $stateCount[2]) / 3.0;
foreach ($this->possibleCenters as $center) {
// Look for about the same center and module size:
if ($center->aboutEquals($estimatedModuleSize, $centerI, $centerJ)) {
return $center->combineEstimate($centerI, $centerJ, $estimatedModuleSize);
}
}
// Hadn't found this before; save it
$point = new AlignmentPattern($centerJ, $centerI, $estimatedModuleSize);
$this->possibleCenters[] = $point;
if ($this->resultPointCallback != null) {
$this->resultPointCallback->foundPossibleResultPoint($point);
}
}
return null;
}
/**
* Given a count of black/white/black pixels just seen and an end position,
* figures the location of the center of this black/white/black run.
*/
private static function centerFromEnd($stateCount, $end)
{
return (float)($end - $stateCount[2]) - $stateCount[1] / 2.0;
}
/**
* <p>After a horizontal scan finds a potential alignment pattern, this method
* "cross-checks" by scanning down vertically through the center of the possible
* alignment pattern to see if the same proportion is detected.</p>
*
* @param int row $startI where an alignment pattern was detected
* @param float center $centerJ of the section that appears to cross an alignment pattern
* @param int maximum $maxCount reasonable number of modules that should be
* observed in any reading state, based on the results of the horizontal scan
*
* @return float vertical center of alignment pattern, or {@link Float#NaN} if not found
*/
private function crossCheckVertical(
$startI,
$centerJ,
$maxCount,
$originalStateCountTotal
)
{
$image = $this->image;
$maxI = $image->getHeight();
$stateCount = $this->crossCheckStateCount;
$stateCount[0] = 0;
$stateCount[1] = 0;
$stateCount[2] = 0;
// Start counting up from center
$i = $startI;
while ($i >= 0 && $image->get($centerJ, $i) && $stateCount[1] <= $maxCount) {
$stateCount[1]++;
$i--;
}
// If already too many modules in this state or ran off the edge:
if ($i < 0 || $stateCount[1] > $maxCount) {
return NAN;
}
while ($i >= 0 && !$image->get($centerJ, $i) && $stateCount[0] <= $maxCount) {
$stateCount[0]++;
$i--;
}
if ($stateCount[0] > $maxCount) {
return NAN;
}
// Now also count down from center
$i = $startI + 1;
while ($i < $maxI && $image->get($centerJ, $i) && $stateCount[1] <= $maxCount) {
$stateCount[1]++;
$i++;
}
if ($i == $maxI || $stateCount[1] > $maxCount) {
return NAN;
}
while ($i < $maxI && !$image->get($centerJ, $i) && $stateCount[2] <= $maxCount) {
$stateCount[2]++;
$i++;
}
if ($stateCount[2] > $maxCount) {
return NAN;
}
$stateCountTotal = $stateCount[0] + $stateCount[1] + $stateCount[2];
if (5 * abs($stateCountTotal - $originalStateCountTotal) >= 2 * $originalStateCountTotal) {
return NAN;
}
return $this->foundPatternCross($stateCount) ? self::centerFromEnd($stateCount, $i) : NAN;
}
}

428
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Detector/Detector.php vendored Normal file
View File

@@ -0,0 +1,428 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Detector;
use Zxing\Common\Detector\MathUtils;
use Zxing\Common\DetectorResult;
use Zxing\Common\GridSampler;
use Zxing\Common\PerspectiveTransform;
use Zxing\DecodeHintType;
use Zxing\FormatException;
use Zxing\NotFoundException;
use Zxing\Qrcode\Decoder\Version;
use Zxing\ResultPoint;
use Zxing\ResultPointCallback;
/**
* <p>Encapsulates logic that can detect a QR Code in an image, even if the QR Code
* is rotated or skewed, or partially obscured.</p>
*
* @author Sean Owen
*/
class Detector
{
private $resultPointCallback;
public function __construct(private $image)
{
}
/**
* <p>Detects a QR Code in an image.</p>
*
* @param array|null optional $hints hints to detector
*
* @return {@link DetectorResult} encapsulating results of detecting a QR Code
* @throws NotFoundException if QR Code cannot be found
* @throws FormatException if a QR Code cannot be decoded
*/
final public function detect($hints = null)
{/*Map<DecodeHintType,?>*/
$resultPointCallback = $hints == null ? null :
$hints->get('NEED_RESULT_POINT_CALLBACK');
/* resultPointCallback = hints == null ? null :
(ResultPointCallback) hints.get(DecodeHintType.NEED_RESULT_POINT_CALLBACK);*/
$finder = new FinderPatternFinder($this->image, $resultPointCallback);
$info = $finder->find($hints);
return $this->processFinderPatternInfo($info);
}
final protected function processFinderPatternInfo($info): \Zxing\Common\DetectorResult
{
$topLeft = $info->getTopLeft();
$topRight = $info->getTopRight();
$bottomLeft = $info->getBottomLeft();
$moduleSize = (float)$this->calculateModuleSize($topLeft, $topRight, $bottomLeft);
if ($moduleSize < 1.0) {
throw NotFoundException::getNotFoundInstance();
}
$dimension = (int)self::computeDimension($topLeft, $topRight, $bottomLeft, $moduleSize);
$provisionalVersion = \Zxing\Qrcode\Decoder\Version::getProvisionalVersionForDimension($dimension);
$modulesBetweenFPCenters = $provisionalVersion->getDimensionForVersion() - 7;
$alignmentPattern = null;
// Anything above version 1 has an alignment pattern
if ((is_countable($provisionalVersion->getAlignmentPatternCenters()) ? count($provisionalVersion->getAlignmentPatternCenters()) : 0) > 0) {
// Guess where a "bottom right" finder pattern would have been
$bottomRightX = $topRight->getX() - $topLeft->getX() + $bottomLeft->getX();
$bottomRightY = $topRight->getY() - $topLeft->getY() + $bottomLeft->getY();
// Estimate that alignment pattern is closer by 3 modules
// from "bottom right" to known top left location
$correctionToTopLeft = 1.0 - 3.0 / (float)$modulesBetweenFPCenters;
$estAlignmentX = (int)($topLeft->getX() + $correctionToTopLeft * ($bottomRightX - $topLeft->getX()));
$estAlignmentY = (int)($topLeft->getY() + $correctionToTopLeft * ($bottomRightY - $topLeft->getY()));
// Kind of arbitrary -- expand search radius before giving up
for ($i = 4; $i <= 16; $i <<= 1) {//??????????
try {
$alignmentPattern = $this->findAlignmentInRegion(
$moduleSize,
$estAlignmentX,
$estAlignmentY,
(float)$i
);
break;
} catch (NotFoundException) {
// try next round
}
}
// If we didn't find alignment pattern... well try anyway without it
}
$transform = self::createTransform($topLeft, $topRight, $bottomLeft, $alignmentPattern, $dimension);
$bits = self::sampleGrid($this->image, $transform, $dimension);
$points = [];
if ($alignmentPattern == null) {
$points = [$bottomLeft, $topLeft, $topRight];
} else {
// die('$points = new ResultPoint[]{bottomLeft, topLeft, topRight, alignmentPattern};');
$points = [$bottomLeft, $topLeft, $topRight, $alignmentPattern];
}
return new DetectorResult($bits, $points);
}
/**
* <p>Detects a QR Code in an image.</p>
*
* @return {@link DetectorResult} encapsulating results of detecting a QR Code
* @throws NotFoundException if QR Code cannot be found
* @throws FormatException if a QR Code cannot be decoded
*/
/**
* <p>Computes an average estimated module size based on estimated derived from the positions
* of the three finder patterns.</p>
*
* @param detected $topLeft top-left finder pattern center
* @param detected $topRight top-right finder pattern center
* @param detected $bottomLeft bottom-left finder pattern center
*
* @return estimated module size
*/
final protected function calculateModuleSize($topLeft, $topRight, $bottomLeft)
{
// Take the average
return ($this->calculateModuleSizeOneWay($topLeft, $topRight) +
$this->calculateModuleSizeOneWay($topLeft, $bottomLeft)) / 2.0;
}
/**
* <p>Estimates module size based on two finder patterns -- it uses
* {@link #sizeOfBlackWhiteBlackRunBothWays(int, int, int, int)} to figure the
* width of each, measuring along the axis between their centers.</p>
*/
private function calculateModuleSizeOneWay($pattern, $otherPattern)
{
$moduleSizeEst1 = $this->sizeOfBlackWhiteBlackRunBothWays(
$pattern->getX(),
(int)$pattern->getY(),
(int)$otherPattern->getX(),
(int)$otherPattern->getY()
);
$moduleSizeEst2 = $this->sizeOfBlackWhiteBlackRunBothWays(
(int)$otherPattern->getX(),
(int)$otherPattern->getY(),
(int)$pattern->getX(),
(int)$pattern->getY()
);
if (is_nan($moduleSizeEst1)) {
return $moduleSizeEst2 / 7.0;
}
if (is_nan($moduleSizeEst2)) {
return $moduleSizeEst1 / 7.0;
}
// Average them, and divide by 7 since we've counted the width of 3 black modules,
// and 1 white and 1 black module on either side. Ergo, divide sum by 14.
return ($moduleSizeEst1 + $moduleSizeEst2) / 14.0;
}
/**
* See {@link #sizeOfBlackWhiteBlackRun(int, int, int, int)}; computes the total width of
* a finder pattern by looking for a black-white-black run from the center in the direction
* of another po$(another finder pattern center), and in the opposite direction too.</p>
*/
private function sizeOfBlackWhiteBlackRunBothWays($fromX, $fromY, $toX, $toY)
{
$result = $this->sizeOfBlackWhiteBlackRun($fromX, $fromY, $toX, $toY);
// Now count other way -- don't run off image though of course
$scale = 1.0;
$otherToX = $fromX - ($toX - $fromX);
if ($otherToX < 0) {
$scale = (float)$fromX / (float)($fromX - $otherToX);
$otherToX = 0;
} elseif ($otherToX >= $this->image->getWidth()) {
$scale = (float)($this->image->getWidth() - 1 - $fromX) / (float)($otherToX - $fromX);
$otherToX = $this->image->getWidth() - 1;
}
$otherToY = (int)($fromY - ($toY - $fromY) * $scale);
$scale = 1.0;
if ($otherToY < 0) {
$scale = (float)$fromY / (float)($fromY - $otherToY);
$otherToY = 0;
} elseif ($otherToY >= $this->image->getHeight()) {
$scale = (float)($this->image->getHeight() - 1 - $fromY) / (float)($otherToY - $fromY);
$otherToY = $this->image->getHeight() - 1;
}
$otherToX = (int)($fromX + ($otherToX - $fromX) * $scale);
$result += $this->sizeOfBlackWhiteBlackRun($fromX, $fromY, $otherToX, $otherToY);
// Middle pixel is double-counted this way; subtract 1
return $result - 1.0;
}
/**
* <p>This method traces a line from a po$in the image, in the direction towards another point.
* It begins in a black region, and keeps going until it finds white, then black, then white again.
* It reports the distance from the start to this point.</p>
*
* <p>This is used when figuring out how wide a finder pattern is, when the finder pattern
* may be skewed or rotated.</p>
*/
private function sizeOfBlackWhiteBlackRun($fromX, $fromY, $toX, $toY)
{
// Mild variant of Bresenham's algorithm;
// see http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
$steep = abs($toY - $fromY) > abs($toX - $fromX);
if ($steep) {
$temp = $fromX;
$fromX = $fromY;
$fromY = $temp;
$temp = $toX;
$toX = $toY;
$toY = $temp;
}
$dx = abs($toX - $fromX);
$dy = abs($toY - $fromY);
$error = -$dx / 2;
$xstep = $fromX < $toX ? 1 : -1;
$ystep = $fromY < $toY ? 1 : -1;
// In black pixels, looking for white, first or second time.
$state = 0;
// Loop up until x == toX, but not beyond
$xLimit = $toX + $xstep;
for ($x = $fromX, $y = $fromY; $x != $xLimit; $x += $xstep) {
$realX = $steep ? $y : $x;
$realY = $steep ? $x : $y;
// Does current pixel mean we have moved white to black or vice versa?
// Scanning black in state 0,2 and white in state 1, so if we find the wrong
// color, advance to next state or end if we are in state 2 already
if (($state == 1) == $this->image->get($realX, $realY)) {
if ($state == 2) {
return MathUtils::distance($x, $y, $fromX, $fromY);
}
$state++;
}
$error += $dy;
if ($error > 0) {
if ($y == $toY) {
break;
}
$y += $ystep;
$error -= $dx;
}
}
// Found black-white-black; give the benefit of the doubt that the next pixel outside the image
// is "white" so this last po$at (toX+xStep,toY) is the right ending. This is really a
// small approximation; (toX+xStep,toY+yStep) might be really correct. Ignore this.
if ($state == 2) {
return MathUtils::distance($toX + $xstep, $toY, $fromX, $fromY);
}
// else we didn't find even black-white-black; no estimate is really possible
return NAN;
}
/**
* <p>Computes the dimension (number of modules on a size) of the QR Code based on the position
* of the finder patterns and estimated module size.</p>
*/
private static function computeDimension(
$topLeft,
$topRight,
$bottomLeft,
$moduleSize
)
{
$tltrCentersDimension = MathUtils::round(ResultPoint::distance($topLeft, $topRight) / $moduleSize);
$tlblCentersDimension = MathUtils::round(ResultPoint::distance($topLeft, $bottomLeft) / $moduleSize);
$dimension = (($tltrCentersDimension + $tlblCentersDimension) / 2) + 7;
switch ($dimension & 0x03) { // mod 4
case 0:
$dimension++;
break;
// 1? do nothing
case 2:
$dimension--;
break;
case 3:
throw NotFoundException::getNotFoundInstance();
}
return $dimension;
}
/**
* <p>Attempts to locate an alignment pattern in a limited region of the image, which is
* guessed to contain it. This method uses {@link AlignmentPattern}.</p>
*
* @param estimated $overallEstModuleSize module size so far
* @param x $estAlignmentX coordinate of center of area probably containing alignment pattern
* @param y $estAlignmentY coordinate of above
* @param number $allowanceFactor of pixels in all directions to search from the center
*
* @return {@link AlignmentPattern} if found, or null otherwise
* @throws NotFoundException if an unexpected error occurs during detection
*/
final protected function findAlignmentInRegion(
$overallEstModuleSize,
$estAlignmentX,
$estAlignmentY,
$allowanceFactor
)
{
// Look for an alignment pattern (3 modules in size) around where it
// should be
$allowance = (int)($allowanceFactor * $overallEstModuleSize);
$alignmentAreaLeftX = max(0, $estAlignmentX - $allowance);
$alignmentAreaRightX = min($this->image->getWidth() - 1, $estAlignmentX + $allowance);
if ($alignmentAreaRightX - $alignmentAreaLeftX < $overallEstModuleSize * 3) {
throw NotFoundException::getNotFoundInstance();
}
$alignmentAreaTopY = max(0, $estAlignmentY - $allowance);
$alignmentAreaBottomY = min($this->image->getHeight() - 1, $estAlignmentY + $allowance);
if ($alignmentAreaBottomY - $alignmentAreaTopY < $overallEstModuleSize * 3) {
throw NotFoundException::getNotFoundInstance();
}
$alignmentFinder =
new AlignmentPatternFinder(
$this->image,
$alignmentAreaLeftX,
$alignmentAreaTopY,
$alignmentAreaRightX - $alignmentAreaLeftX,
$alignmentAreaBottomY - $alignmentAreaTopY,
$overallEstModuleSize,
$this->resultPointCallback
);
return $alignmentFinder->find();
}
private static function createTransform(
$topLeft,
$topRight,
$bottomLeft,
$alignmentPattern,
$dimension
)
{
$dimMinusThree = (float)$dimension - 3.5;
$bottomRightX = 0.0;
$bottomRightY = 0.0;
$sourceBottomRightX = 0.0;
$sourceBottomRightY = 0.0;
if ($alignmentPattern != null) {
$bottomRightX = $alignmentPattern->getX();
$bottomRightY = $alignmentPattern->getY();
$sourceBottomRightX = $dimMinusThree - 3.0;
$sourceBottomRightY = $sourceBottomRightX;
} else {
// Don't have an alignment pattern, just make up the bottom-right point
$bottomRightX = ($topRight->getX() - $topLeft->getX()) + $bottomLeft->getX();
$bottomRightY = ($topRight->getY() - $topLeft->getY()) + $bottomLeft->getY();
$sourceBottomRightX = $dimMinusThree;
$sourceBottomRightY = $dimMinusThree;
}
return PerspectiveTransform::quadrilateralToQuadrilateral(
3.5,
3.5,
$dimMinusThree,
3.5,
$sourceBottomRightX,
$sourceBottomRightY,
3.5,
$dimMinusThree,
$topLeft->getX(),
$topLeft->getY(),
$topRight->getX(),
$topRight->getY(),
$bottomRightX,
$bottomRightY,
$bottomLeft->getX(),
$bottomLeft->getY()
);
}
private static function sampleGrid(
$image,
$transform,
$dimension
)
{
$sampler = GridSampler::getInstance();
return $sampler->sampleGrid_($image, $dimension, $dimension, $transform);
}
final protected function getImage()
{
return $this->image;
}
final protected function getResultPointCallback()
{
return $this->resultPointCallback;
}
}

81
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Detector/FinderPattern.php vendored Normal file
View File

@@ -0,0 +1,81 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Detector;
use Zxing\ResultPoint;
/**
* <p>Encapsulates a finder pattern, which are the three square patterns found in
* the corners of QR Codes. It also encapsulates a count of similar finder patterns,
* as a convenience to the finder's bookkeeping.</p>
*
* @author Sean Owen
*/
final class FinderPattern extends ResultPoint
{
public function __construct($posX, $posY, private $estimatedModuleSize, private $count = 1)
{
parent::__construct($posX, $posY);
}
public function getEstimatedModuleSize()
{
return $this->estimatedModuleSize;
}
public function getCount()
{
return $this->count;
}
/*
void incrementCount() {
this.count++;
}
*/
/**
* <p>Determines if this finder pattern "about equals" a finder pattern at the stated
* position and size -- meaning, it is at nearly the same center with nearly the same size.</p>
*/
public function aboutEquals($moduleSize, $i, $j)
{
if (abs($i - $this->getY()) <= $moduleSize && abs($j - $this->getX()) <= $moduleSize) {
$moduleSizeDiff = abs($moduleSize - $this->estimatedModuleSize);
return $moduleSizeDiff <= 1.0 || $moduleSizeDiff <= $this->estimatedModuleSize;
}
return false;
}
/**
* Combines this object's current estimate of a finder pattern position and module size
* with a new estimate. It returns a new {@code FinderPattern} containing a weighted average
* based on count.
*/
public function combineEstimate($i, $j, $newModuleSize): \Zxing\Qrcode\Detector\FinderPattern
{
$combinedCount = $this->count + 1;
$combinedX = ($this->count * $this->getX() + $j) / $combinedCount;
$combinedY = ($this->count * $this->getY() + $i) / $combinedCount;
$combinedModuleSize = ($this->count * $this->estimatedModuleSize + $newModuleSize) / $combinedCount;
return new FinderPattern($combinedX, $combinedY, $combinedModuleSize, $combinedCount);
}
}

700
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Detector/FinderPatternFinder.php vendored Normal file
View File

@@ -0,0 +1,700 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Detector;
use Zxing\Common\BitMatrix;
use Zxing\NotFoundException;
use Zxing\ResultPoint;
/**
* <p>This class attempts to find finder patterns in a QR Code. Finder patterns are the square
* markers at three corners of a QR Code.</p>
*
* <p>This class is thread-safe but not reentrant. Each thread must allocate its own object.
*
* @author Sean Owen
*/
class FinderPatternFinder
{
protected static int $MIN_SKIP = 3;
protected static int $MAX_MODULES = 57; // 1 pixel/module times 3 modules/center
private static int $CENTER_QUORUM = 2;
private ?float $average = null;
private array $possibleCenters = []; //private final List<FinderPattern> possibleCenters;
private bool $hasSkipped = false;
/**
* @var mixed|int[]
*/
private $crossCheckStateCount;
/**
* <p>Creates a finder that will search the image for three finder patterns.</p>
*
* @param BitMatrix $image image to search
*/
public function __construct(private $image, private $resultPointCallback = null)
{
//new ArrayList<>();
$this->crossCheckStateCount = fill_array(0, 5, 0);
}
final public function find($hints): \Zxing\Qrcode\Detector\FinderPatternInfo
{/*final FinderPatternInfo find(Map<DecodeHintType,?> hints) throws NotFoundException {*/
$tryHarder = $hints != null && $hints['TRY_HARDER'];
$pureBarcode = $hints != null && $hints['PURE_BARCODE'];
$maxI = $this->image->getHeight();
$maxJ = $this->image->getWidth();
// We are looking for black/white/black/white/black modules in
// 1:1:3:1:1 ratio; this tracks the number of such modules seen so far
// Let's assume that the maximum version QR Code we support takes up 1/4 the height of the
// image, and then account for the center being 3 modules in size. This gives the smallest
// number of pixels the center could be, so skip this often. When trying harder, look for all
// QR versions regardless of how dense they are.
$iSkip = (int)((3 * $maxI) / (4 * self::$MAX_MODULES));
if ($iSkip < self::$MIN_SKIP || $tryHarder) {
$iSkip = self::$MIN_SKIP;
}
$done = false;
$stateCount = [];
for ($i = $iSkip - 1; $i < $maxI && !$done; $i += $iSkip) {
// Get a row of black/white values
$stateCount[0] = 0;
$stateCount[1] = 0;
$stateCount[2] = 0;
$stateCount[3] = 0;
$stateCount[4] = 0;
$currentState = 0;
for ($j = 0; $j < $maxJ; $j++) {
if ($this->image->get($j, $i)) {
// Black pixel
if (($currentState & 1) == 1) { // Counting white pixels
$currentState++;
}
$stateCount[$currentState]++;
} else { // White pixel
if (($currentState & 1) == 0) { // Counting black pixels
if ($currentState == 4) { // A winner?
if (self::foundPatternCross($stateCount)) { // Yes
$confirmed = $this->handlePossibleCenter($stateCount, $i, $j, $pureBarcode);
if ($confirmed) {
// Start examining every other line. Checking each line turned out to be too
// expensive and didn't improve performance.
$iSkip = 3;
if ($this->hasSkipped) {
$done = $this->haveMultiplyConfirmedCenters();
} else {
$rowSkip = $this->findRowSkip();
if ($rowSkip > $stateCount[2]) {
// Skip rows between row of lower confirmed center
// and top of presumed third confirmed center
// but back up a bit to get a full chance of detecting
// it, entire width of center of finder pattern
// Skip by rowSkip, but back off by $stateCount[2] (size of last center
// of pattern we saw) to be conservative, and also back off by iSkip which
// is about to be re-added
$i += $rowSkip - $stateCount[2] - $iSkip;
$j = $maxJ - 1;
}
}
} else {
$stateCount[0] = $stateCount[2];
$stateCount[1] = $stateCount[3];
$stateCount[2] = $stateCount[4];
$stateCount[3] = 1;
$stateCount[4] = 0;
$currentState = 3;
continue;
}
// Clear state to start looking again
$currentState = 0;
$stateCount[0] = 0;
$stateCount[1] = 0;
$stateCount[2] = 0;
$stateCount[3] = 0;
$stateCount[4] = 0;
} else { // No, shift counts back by two
$stateCount[0] = $stateCount[2];
$stateCount[1] = $stateCount[3];
$stateCount[2] = $stateCount[4];
$stateCount[3] = 1;
$stateCount[4] = 0;
$currentState = 3;
}
} else {
$stateCount[++$currentState]++;
}
} else { // Counting white pixels
$stateCount[$currentState]++;
}
}
}
if (self::foundPatternCross($stateCount)) {
$confirmed = $this->handlePossibleCenter($stateCount, $i, $maxJ, $pureBarcode);
if ($confirmed) {
$iSkip = $stateCount[0];
if ($this->hasSkipped) {
// Found a third one
$done = $this->haveMultiplyConfirmedCenters();
}
}
}
}
$patternInfo = $this->selectBestPatterns();
$patternInfo = ResultPoint::orderBestPatterns($patternInfo);
return new FinderPatternInfo($patternInfo);
}
/**
* @param $stateCount ; count of black/white/black/white/black pixels just read
*
* @return true iff the proportions of the counts is close enough to the 1/1/3/1/1 ratios
* used by finder patterns to be considered a match
*/
protected static function foundPatternCross($stateCount)
{
$totalModuleSize = 0;
for ($i = 0; $i < 5; $i++) {
$count = $stateCount[$i];
if ($count == 0) {
return false;
}
$totalModuleSize += $count;
}
if ($totalModuleSize < 7) {
return false;
}
$moduleSize = $totalModuleSize / 7.0;
$maxVariance = $moduleSize / 2.0;
// Allow less than 50% variance from 1-1-3-1-1 proportions
return
abs($moduleSize - $stateCount[0]) < $maxVariance &&
abs($moduleSize - $stateCount[1]) < $maxVariance &&
abs(3.0 * $moduleSize - $stateCount[2]) < 3 * $maxVariance &&
abs($moduleSize - $stateCount[3]) < $maxVariance &&
abs($moduleSize - $stateCount[4]) < $maxVariance;
}
/**
* <p>This is called when a horizontal scan finds a possible alignment pattern. It will
* cross check with a vertical scan, and if successful, will, ah, cross-cross-check
* with another horizontal scan. This is needed primarily to locate the real horizontal
* center of the pattern in cases of extreme skew.
* And then we cross-cross-cross check with another diagonal scan.</p>
*
* <p>If that succeeds the finder pattern location is added to a list that tracks
* the number of times each location has been nearly-matched as a finder pattern.
* Each additional find is more evidence that the location is in fact a finder
* pattern center
*
* @param reading $stateCount state module counts from horizontal scan
* @param row $i where finder pattern may be found
* @param end $j of possible finder pattern in row
* @param true $pureBarcode if in "pure barcode" mode
*
* @return true if a finder pattern candidate was found this time
*/
final protected function handlePossibleCenter($stateCount, $i, $j, $pureBarcode)
{
$stateCountTotal = $stateCount[0] + $stateCount[1] + $stateCount[2] + $stateCount[3] +
$stateCount[4];
$centerJ = self::centerFromEnd($stateCount, $j);
$centerI = $this->crossCheckVertical($i, (int)($centerJ), $stateCount[2], $stateCountTotal);
if (!is_nan($centerI)) {
// Re-cross check
$centerJ = $this->crossCheckHorizontal((int)($centerJ), (int)($centerI), $stateCount[2], $stateCountTotal);
if (!is_nan($centerJ) &&
(!$pureBarcode || $this->crossCheckDiagonal((int)($centerI), (int)($centerJ), $stateCount[2], $stateCountTotal))
) {
$estimatedModuleSize = (float)$stateCountTotal / 7.0;
$found = false;
for ($index = 0; $index < count($this->possibleCenters); $index++) {
$center = $this->possibleCenters[$index];
// Look for about the same center and module size:
if ($center->aboutEquals($estimatedModuleSize, $centerI, $centerJ)) {
$this->possibleCenters[$index] = $center->combineEstimate($centerI, $centerJ, $estimatedModuleSize);
$found = true;
break;
}
}
if (!$found) {
$point = new FinderPattern($centerJ, $centerI, $estimatedModuleSize);
$this->possibleCenters[] = $point;
if ($this->resultPointCallback != null) {
$this->resultPointCallback->foundPossibleResultPoint($point);
}
}
return true;
}
}
return false;
}
/**
* Given a count of black/white/black/white/black pixels just seen and an end position,
* figures the location of the center of this run.
*/
private static function centerFromEnd($stateCount, $end)
{
return (float)($end - $stateCount[4] - $stateCount[3]) - $stateCount[2] / 2.0;
}
/**
* <p>After a horizontal scan finds a potential finder pattern, this method
* "cross-checks" by scanning down vertically through the center of the possible
* finder pattern to see if the same proportion is detected.</p>
*
* @param $startI ; row where a finder pattern was detected
* @param $centerJ ; center of the section that appears to cross a finder pattern
* @param $maxCount ; maximum reasonable number of modules that should be
* observed in any reading state, based on the results of the horizontal scan
*
* @return float vertical center of finder pattern, or {@link Float#NaN} if not found
*/
private function crossCheckVertical(
$startI,
$centerJ,
$maxCount,
$originalStateCountTotal
)
{
$image = $this->image;
$maxI = $image->getHeight();
$stateCount = $this->getCrossCheckStateCount();
// Start counting up from center
$i = $startI;
while ($i >= 0 && $image->get($centerJ, $i)) {
$stateCount[2]++;
$i--;
}
if ($i < 0) {
return NAN;
}
while ($i >= 0 && !$image->get($centerJ, $i) && $stateCount[1] <= $maxCount) {
$stateCount[1]++;
$i--;
}
// If already too many modules in this state or ran off the edge:
if ($i < 0 || $stateCount[1] > $maxCount) {
return NAN;
}
while ($i >= 0 && $image->get($centerJ, $i) && $stateCount[0] <= $maxCount) {
$stateCount[0]++;
$i--;
}
if ($stateCount[0] > $maxCount) {
return NAN;
}
// Now also count down from center
$i = $startI + 1;
while ($i < $maxI && $image->get($centerJ, $i)) {
$stateCount[2]++;
$i++;
}
if ($i == $maxI) {
return NAN;
}
while ($i < $maxI && !$image->get($centerJ, $i) && $stateCount[3] < $maxCount) {
$stateCount[3]++;
$i++;
}
if ($i == $maxI || $stateCount[3] >= $maxCount) {
return NAN;
}
while ($i < $maxI && $image->get($centerJ, $i) && $stateCount[4] < $maxCount) {
$stateCount[4]++;
$i++;
}
if ($stateCount[4] >= $maxCount) {
return NAN;
}
// If we found a finder-pattern-like section, but its size is more than 40% different than
// the original, assume it's a false positive
$stateCountTotal = $stateCount[0] + $stateCount[1] + $stateCount[2] + $stateCount[3] +
$stateCount[4];
if (5 * abs($stateCountTotal - $originalStateCountTotal) >= 2 * $originalStateCountTotal) {
return NAN;
}
return self::foundPatternCross($stateCount) ? self::centerFromEnd($stateCount, $i) : NAN;
}
private function getCrossCheckStateCount()
{
$this->crossCheckStateCount[0] = 0;
$this->crossCheckStateCount[1] = 0;
$this->crossCheckStateCount[2] = 0;
$this->crossCheckStateCount[3] = 0;
$this->crossCheckStateCount[4] = 0;
return $this->crossCheckStateCount;
}
/**
* <p>Like {@link #crossCheckVertical(int, int, int, int)}, and in fact is basically identical,
* except it reads horizontally instead of vertically. This is used to cross-cross
* check a vertical cross check and locate the real center of the alignment pattern.</p>
*/
private function crossCheckHorizontal(
$startJ,
$centerI,
$maxCount,
$originalStateCountTotal
)
{
$image = $this->image;
$maxJ = $this->image->getWidth();
$stateCount = $this->getCrossCheckStateCount();
$j = $startJ;
while ($j >= 0 && $image->get($j, $centerI)) {
$stateCount[2]++;
$j--;
}
if ($j < 0) {
return NAN;
}
while ($j >= 0 && !$image->get($j, $centerI) && $stateCount[1] <= $maxCount) {
$stateCount[1]++;
$j--;
}
if ($j < 0 || $stateCount[1] > $maxCount) {
return NAN;
}
while ($j >= 0 && $image->get($j, $centerI) && $stateCount[0] <= $maxCount) {
$stateCount[0]++;
$j--;
}
if ($stateCount[0] > $maxCount) {
return NAN;
}
$j = $startJ + 1;
while ($j < $maxJ && $image->get($j, $centerI)) {
$stateCount[2]++;
$j++;
}
if ($j == $maxJ) {
return NAN;
}
while ($j < $maxJ && !$image->get($j, $centerI) && $stateCount[3] < $maxCount) {
$stateCount[3]++;
$j++;
}
if ($j == $maxJ || $stateCount[3] >= $maxCount) {
return NAN;
}
while ($j < $maxJ && $this->image->get($j, $centerI) && $stateCount[4] < $maxCount) {
$stateCount[4]++;
$j++;
}
if ($stateCount[4] >= $maxCount) {
return NAN;
}
// If we found a finder-pattern-like section, but its size is significantly different than
// the original, assume it's a false positive
$stateCountTotal = $stateCount[0] + $stateCount[1] + $stateCount[2] + $stateCount[3] +
$stateCount[4];
if (5 * abs($stateCountTotal - $originalStateCountTotal) >= $originalStateCountTotal) {
return NAN;
}
return static::foundPatternCross($stateCount) ? self::centerFromEnd($stateCount, $j) : NAN;
}
/**
* After a vertical and horizontal scan finds a potential finder pattern, this method
* "cross-cross-cross-checks" by scanning down diagonally through the center of the possible
* finder pattern to see if the same proportion is detected.
*
* @param $startI ; row where a finder pattern was detected
* @param $centerJ ; center of the section that appears to cross a finder pattern
* @param $maxCount ; maximum reasonable number of modules that should be
* observed in any reading state, based on the results of the horizontal scan
* @param $originalStateCountTotal ; The original state count total.
*
* @return true if proportions are withing expected limits
*/
private function crossCheckDiagonal($startI, $centerJ, $maxCount, $originalStateCountTotal)
{
$stateCount = $this->getCrossCheckStateCount();
// Start counting up, left from center finding black center mass
$i = 0;
$startI = (int)($startI);
$centerJ = (int)($centerJ);
while ($startI >= $i && $centerJ >= $i && $this->image->get($centerJ - $i, $startI - $i)) {
$stateCount[2]++;
$i++;
}
if ($startI < $i || $centerJ < $i) {
return false;
}
// Continue up, left finding white space
while ($startI >= $i && $centerJ >= $i && !$this->image->get($centerJ - $i, $startI - $i) &&
$stateCount[1] <= $maxCount) {
$stateCount[1]++;
$i++;
}
// If already too many modules in this state or ran off the edge:
if ($startI < $i || $centerJ < $i || $stateCount[1] > $maxCount) {
return false;
}
// Continue up, left finding black border
while ($startI >= $i && $centerJ >= $i && $this->image->get($centerJ - $i, $startI - $i) &&
$stateCount[0] <= $maxCount) {
$stateCount[0]++;
$i++;
}
if ($stateCount[0] > $maxCount) {
return false;
}
$maxI = $this->image->getHeight();
$maxJ = $this->image->getWidth();
// Now also count down, right from center
$i = 1;
while ($startI + $i < $maxI && $centerJ + $i < $maxJ && $this->image->get($centerJ + $i, $startI + $i)) {
$stateCount[2]++;
$i++;
}
// Ran off the edge?
if ($startI + $i >= $maxI || $centerJ + $i >= $maxJ) {
return false;
}
while ($startI + $i < $maxI && $centerJ + $i < $maxJ && !$this->image->get($centerJ + $i, $startI + $i) &&
$stateCount[3] < $maxCount) {
$stateCount[3]++;
$i++;
}
if ($startI + $i >= $maxI || $centerJ + $i >= $maxJ || $stateCount[3] >= $maxCount) {
return false;
}
while ($startI + $i < $maxI && $centerJ + $i < $maxJ && $this->image->get($centerJ + $i, $startI + $i) &&
$stateCount[4] < $maxCount) {
$stateCount[4]++;
$i++;
}
if ($stateCount[4] >= $maxCount) {
return false;
}
// If we found a finder-pattern-like section, but its size is more than 100% different than
// the original, assume it's a false positive
$stateCountTotal = $stateCount[0] + $stateCount[1] + $stateCount[2] + $stateCount[3] + $stateCount[4];
return
abs($stateCountTotal - $originalStateCountTotal) < 2 * $originalStateCountTotal &&
self::foundPatternCross($stateCount);
}
/**
* @return true iff we have found at least 3 finder patterns that have been detected
* at least {@link #CENTER_QUORUM} times each, and, the estimated module size of the
* candidates is "pretty similar"
*/
private function haveMultiplyConfirmedCenters()
{
$confirmedCount = 0;
$totalModuleSize = 0.0;
$max = count($this->possibleCenters);
foreach ($this->possibleCenters as $pattern) {
if ($pattern->getCount() >= self::$CENTER_QUORUM) {
$confirmedCount++;
$totalModuleSize += $pattern->getEstimatedModuleSize();
}
}
if ($confirmedCount < 3) {
return false;
}
// OK, we have at least 3 confirmed centers, but, it's possible that one is a "false positive"
// and that we need to keep looking. We detect this by asking if the estimated module sizes
// vary too much. We arbitrarily say that when the total deviation from average exceeds
// 5% of the total module size estimates, it's too much.
$average = $totalModuleSize / (float)$max;
$totalDeviation = 0.0;
foreach ($this->possibleCenters as $pattern) {
$totalDeviation += abs($pattern->getEstimatedModuleSize() - $average);
}
return $totalDeviation <= 0.05 * $totalModuleSize;
}
/**
* @return int number of rows we could safely skip during scanning, based on the first
* two finder patterns that have been located. In some cases their position will
* allow us to infer that the third pattern must lie below a certain point farther
* down in the image.
*/
private function findRowSkip()
{
$max = count($this->possibleCenters);
if ($max <= 1) {
return 0;
}
$firstConfirmedCenter = null;
foreach ($this->possibleCenters as $center) {
if ($center->getCount() >= self::$CENTER_QUORUM) {
if ($firstConfirmedCenter == null) {
$firstConfirmedCenter = $center;
} else {
// We have two confirmed centers
// How far down can we skip before resuming looking for the next
// pattern? In the worst case, only the difference between the
// difference in the x / y coordinates of the two centers.
// This is the case where you find top left last.
$this->hasSkipped = true;
return (int)((abs($firstConfirmedCenter->getX() - $center->getX()) -
abs($firstConfirmedCenter->getY() - $center->getY())) / 2);
}
}
}
return 0;
}
/**
* @return array the 3 best {@link FinderPattern}s from our list of candidates. The "best" are
* those that have been detected at least {@link #CENTER_QUORUM} times, and whose module
* size differs from the average among those patterns the least
* @throws NotFoundException if 3 such finder patterns do not exist
*/
private function selectBestPatterns()
{
$startSize = count($this->possibleCenters);
if ($startSize < 3) {
// Couldn't find enough finder patterns
throw new NotFoundException();
}
// Filter outlier possibilities whose module size is too different
if ($startSize > 3) {
// But we can only afford to do so if we have at least 4 possibilities to choose from
$totalModuleSize = 0.0;
$square = 0.0;
foreach ($this->possibleCenters as $center) {
$size = $center->getEstimatedModuleSize();
$totalModuleSize += $size;
$square += $size * $size;
}
$this->average = $totalModuleSize / (float)$startSize;
$stdDev = (float)sqrt($square / $startSize - $this->average * $this->average);
usort($this->possibleCenters, $this->FurthestFromAverageComparator(...));
$limit = max(0.2 * $this->average, $stdDev);
for ($i = 0; $i < count($this->possibleCenters) && count($this->possibleCenters) > 3; $i++) {
$pattern = $this->possibleCenters[$i];
if (abs($pattern->getEstimatedModuleSize() - $this->average) > $limit) {
unset($this->possibleCenters[$i]);//возможно что ключи меняются в java при вызове .remove(i) ???
$this->possibleCenters = array_values($this->possibleCenters);
$i--;
}
}
}
if (count($this->possibleCenters) > 3) {
// Throw away all but those first size candidate points we found.
$totalModuleSize = 0.0;
foreach ($this->possibleCenters as $possibleCenter) {
$totalModuleSize += $possibleCenter->getEstimatedModuleSize();
}
$this->average = $totalModuleSize / (float)count($this->possibleCenters);
usort($this->possibleCenters, $this->CenterComparator(...));
array_slice($this->possibleCenters, 3, count($this->possibleCenters) - 3);
}
return [$this->possibleCenters[0], $this->possibleCenters[1], $this->possibleCenters[2]];
}
/**
* <p>Orders by furthest from average</p>
*/
public function FurthestFromAverageComparator($center1, $center2)
{
$dA = abs($center2->getEstimatedModuleSize() - $this->average);
$dB = abs($center1->getEstimatedModuleSize() - $this->average);
if ($dA < $dB) {
return -1;
} elseif ($dA == $dB) {
return 0;
} else {
return 1;
}
}
public function CenterComparator($center1, $center2)
{
if ($center2->getCount() == $center1->getCount()) {
$dA = abs($center2->getEstimatedModuleSize() - $this->average);
$dB = abs($center1->getEstimatedModuleSize() - $this->average);
if ($dA < $dB) {
return 1;
} elseif ($dA == $dB) {
return 0;
} else {
return -1;
}
} else {
return $center2->getCount() - $center1->getCount();
}
}
final protected function getImage()
{
return $this->image;
}
/**
* <p>Orders by {@link FinderPattern#getCount()}, descending.</p>
*/
//@Override
final protected function getPossibleCenters()
{ //List<FinderPattern> getPossibleCenters()
return $this->possibleCenters;
}
}

53
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/Detector/FinderPatternInfo.php vendored Normal file
View File

@@ -0,0 +1,53 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode\Detector;
/**
* <p>Encapsulates information about finder patterns in an image, including the location of
* the three finder patterns, and their estimated module size.</p>
*
* @author Sean Owen
*/
final class FinderPatternInfo
{
private $bottomLeft;
private $topLeft;
private $topRight;
public function __construct($patternCenters)
{
$this->bottomLeft = $patternCenters[0];
$this->topLeft = $patternCenters[1];
$this->topRight = $patternCenters[2];
}
public function getBottomLeft()
{
return $this->bottomLeft;
}
public function getTopLeft()
{
return $this->topLeft;
}
public function getTopRight()
{
return $this->topRight;
}
}

221
vendor/khanamiryan/qrcode-detector-decoder/lib/Qrcode/QRCodeReader.php vendored Normal file
View File

@@ -0,0 +1,221 @@
<?php
/*
* Copyright 2007 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace Zxing\Qrcode;
use Zxing\BinaryBitmap;
use Zxing\ChecksumException;
use Zxing\Common\BitMatrix;
use Zxing\FormatException;
use Zxing\NotFoundException;
use Zxing\Qrcode\Decoder\Decoder;
use Zxing\Qrcode\Detector\Detector;
use Zxing\Reader;
use Zxing\Result;
/**
* This implementation can detect and decode QR Codes in an image.
*
* @author Sean Owen
*/
class QRCodeReader implements Reader
{
private static array $NO_POINTS = [];
private readonly \Zxing\Qrcode\Decoder\Decoder $decoder;
public function __construct()
{
$this->decoder = new Decoder();
}
/**
* @param null $hints
*
* @return Result
* @throws \Zxing\FormatException
* @throws \Zxing\NotFoundException
*/
public function decode(BinaryBitmap $image, $hints = null)
{
$decoderResult = null;
if ($hints !== null && $hints['PURE_BARCODE']) {
$bits = self::extractPureBits($image->getBlackMatrix());
$decoderResult = $this->decoder->decode($bits, $hints);
$points = self::$NO_POINTS;
} else {
$detector = new Detector($image->getBlackMatrix());
$detectorResult = $detector->detect($hints);
$decoderResult = $this->decoder->decode($detectorResult->getBits(), $hints);
$points = $detectorResult->getPoints();
}
$result = new Result($decoderResult->getText(), $decoderResult->getRawBytes(), $points, 'QR_CODE');//BarcodeFormat.QR_CODE
$byteSegments = $decoderResult->getByteSegments();
if ($byteSegments !== null) {
$result->putMetadata('BYTE_SEGMENTS', $byteSegments);//ResultMetadataType.BYTE_SEGMENTS
}
$ecLevel = $decoderResult->getECLevel();
if ($ecLevel !== null) {
$result->putMetadata('ERROR_CORRECTION_LEVEL', $ecLevel);//ResultMetadataType.ERROR_CORRECTION_LEVEL
}
if ($decoderResult->hasStructuredAppend()) {
$result->putMetadata(
'STRUCTURED_APPEND_SEQUENCE',//ResultMetadataType.STRUCTURED_APPEND_SEQUENCE
$decoderResult->getStructuredAppendSequenceNumber()
);
$result->putMetadata(
'STRUCTURED_APPEND_PARITY',//ResultMetadataType.STRUCTURED_APPEND_PARITY
$decoderResult->getStructuredAppendParity()
);
}
return $result;
}
/**
* Locates and decodes a QR code in an image.
*
* @return a String representing the content encoded by the QR code
* @throws NotFoundException if a QR code cannot be found
* @throws FormatException if a QR code cannot be decoded
* @throws ChecksumException if error correction fails
*/
/**
* This method detects a code in a "pure" image -- that is, pure monochrome image
* which contains only an unrotated, unskewed, image of a code, with some white border
* around it. This is a specialized method that works exceptionally fast in this special
* case.
*
* @see com.google.zxing.datamatrix.DataMatrixReader#extractPureBits(BitMatrix)
*/
private static function extractPureBits(BitMatrix $image)
{
$leftTopBlack = $image->getTopLeftOnBit();
$rightBottomBlack = $image->getBottomRightOnBit();
if ($leftTopBlack === null || $rightBottomBlack == null) {
throw NotFoundException::getNotFoundInstance();
}
$moduleSize = self::moduleSize($leftTopBlack, $image);
$top = $leftTopBlack[1];
$bottom = $rightBottomBlack[1];
$left = $leftTopBlack[0];
$right = $rightBottomBlack[0];
// Sanity check!
if ($left >= $right || $top >= $bottom) {
throw NotFoundException::getNotFoundInstance();
}
if ($bottom - $top != $right - $left) {
// Special case, where bottom-right module wasn't black so we found something else in the last row
// Assume it's a square, so use height as the width
$right = $left + ($bottom - $top);
}
$matrixWidth = round(($right - $left + 1) / $moduleSize);
$matrixHeight = round(($bottom - $top + 1) / $moduleSize);
if ($matrixWidth <= 0 || $matrixHeight <= 0) {
throw NotFoundException::getNotFoundInstance();
}
if ($matrixHeight != $matrixWidth) {
// Only possibly decode square regions
throw NotFoundException::getNotFoundInstance();
}
// Push in the "border" by half the module width so that we start
// sampling in the middle of the module. Just in case the image is a
// little off, this will help recover.
$nudge = (int)($moduleSize / 2.0);// $nudge = (int) ($moduleSize / 2.0f);
$top += $nudge;
$left += $nudge;
// But careful that this does not sample off the edge
// "right" is the farthest-right valid pixel location -- right+1 is not necessarily
// This is positive by how much the inner x loop below would be too large
$nudgedTooFarRight = $left + (int)(($matrixWidth - 1) * $moduleSize) - $right;
if ($nudgedTooFarRight > 0) {
if ($nudgedTooFarRight > $nudge) {
// Neither way fits; abort
throw NotFoundException::getNotFoundInstance();
}
$left -= $nudgedTooFarRight;
}
// See logic above
$nudgedTooFarDown = $top + (int)(($matrixHeight - 1) * $moduleSize) - $bottom;
if ($nudgedTooFarDown > 0) {
if ($nudgedTooFarDown > $nudge) {
// Neither way fits; abort
throw NotFoundException::getNotFoundInstance();
}
$top -= $nudgedTooFarDown;
}
// Now just read off the bits
$bits = new BitMatrix($matrixWidth, $matrixHeight);
for ($y = 0; $y < $matrixHeight; $y++) {
$iOffset = $top + (int)($y * $moduleSize);
for ($x = 0; $x < $matrixWidth; $x++) {
if ($image->get($left + (int)($x * $moduleSize), $iOffset)) {
$bits->set($x, $y);
}
}
}
return $bits;
}
private static function moduleSize($leftTopBlack, BitMatrix $image)
{
$height = $image->getHeight();
$width = $image->getWidth();
$x = $leftTopBlack[0];
$y = $leftTopBlack[1];
/*$x = $leftTopBlack[0];
$y = $leftTopBlack[1];*/
$inBlack = true;
$transitions = 0;
while ($x < $width && $y < $height) {
if ($inBlack != $image->get($x, $y)) {
if (++$transitions == 5) {
break;
}
$inBlack = !$inBlack;
}
$x++;
$y++;
}
if ($x == $width || $y == $height) {
throw NotFoundException::getNotFoundInstance();
}
return ($x - $leftTopBlack[0]) / 7.0; //return ($x - $leftTopBlack[0]) / 7.0f;
}
public function reset(): void
{
// do nothing
}
final protected function getDecoder()
{
return $this->decoder;
}
}