From 32b6a5ed778bdc8af64e7c431908857075df5e83 Mon Sep 17 00:00:00 2001 From: codemasher Date: Sat, 16 Jan 2021 19:25:13 +0100 Subject: [PATCH] :sparkles: --- NOTICE | 13 ++ README.md | 3 + composer.json | 12 +- src/Common/GF256.php | 152 +++++++++++++++++++ src/Common/GenericGFPoly.php | 278 +++++++++++++++++++++++++++++++++++ 5 files changed, 456 insertions(+), 2 deletions(-) create mode 100644 NOTICE create mode 100644 src/Common/GF256.php create mode 100644 src/Common/GenericGFPoly.php diff --git a/NOTICE b/NOTICE new file mode 100644 index 000000000..98764e2ba --- /dev/null +++ b/NOTICE @@ -0,0 +1,13 @@ +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. diff --git a/README.md b/README.md index cea5509a2..fa36b5044 100644 --- a/README.md +++ b/README.md @@ -102,6 +102,9 @@ Hi, please check out my other projects that are way cooler than qrcodes! ### Disclaimer! I don't take responsibility for molten CPUs, misled applications, failed log-ins etc.. Use at your own risk! +#### License notice +Parts of this code are [ported to php](https://github.com/khanamiryan/php-qrcode-detector-decoder) from the [ZXing project](https://github.com/zxing/zxing) and licensed under the Apache License, Version 2.0. + #### Trademark Notice The word "QR Code" is registered trademark of *DENSO WAVE INCORPORATED*
diff --git a/composer.json b/composer.json index 5ec4031be..536bdf56f 100644 --- a/composer.json +++ b/composer.json @@ -6,12 +6,20 @@ "minimum-stability": "stable", "type": "library", "keywords": [ - "QR code", "qrcode", "qr", "qrcode-generator", "phpqrcode" + "QR code", "qrcode", "qr", "qrcode-generator", "phpqrcode", "qrcode-reader" ], "authors": [ { "name": "Kazuhiko Arase", - "homepage": "https://github.com/kazuhikoarase" + "homepage": "https://github.com/kazuhikoarase/qrcode-generator" + }, + { + "name":"ZXing Authors", + "homepage": "https://github.com/zxing/zxing" + }, + { + "name": "Ashot Khanamiryan", + "homepage": "https://github.com/khanamiryan/php-qrcode-detector-decoder" }, { "name": "Smiley", diff --git a/src/Common/GF256.php b/src/Common/GF256.php new file mode 100644 index 000000000..12c4ad099 --- /dev/null +++ b/src/Common/GF256.php @@ -0,0 +1,152 @@ + + * @copyright 2021 Smiley + * @license Apache-2.0 + */ + +namespace chillerlan\QRCode\Common; + +use InvalidArgumentException; + +use function array_fill; + +/** + *

This class contains utility methods for performing mathematical operations over + * the Galois Fields. Operations use a given primitive polynomial in calculations.

+ * + *

Throughout this package, elements of the GF are represented as an {@code int} + * for convenience and speed (but at the cost of memory). + *

+ * + * @author Sean Owen + * @author David Olivier + */ +final class GF256{ + + /** + * irreducible polynomial whose coefficients are represented by the bits of an int, + * where the least-significant bit represents the constant coefficient + */ +# private int $primitive = 0x011D; + + private const logTable = [ + null, 0, 1, 25, 2, 50, 26, 198, 3, 223, 51, 238, 27, 104, 199, 75, + 4, 100, 224, 14, 52, 141, 239, 129, 28, 193, 105, 248, 200, 8, 76, 113, + 5, 138, 101, 47, 225, 36, 15, 33, 53, 147, 142, 218, 240, 18, 130, 69, + 29, 181, 194, 125, 106, 39, 249, 185, 201, 154, 9, 120, 77, 228, 114, 166, + 6, 191, 139, 98, 102, 221, 48, 253, 226, 152, 37, 179, 16, 145, 34, 136, + 54, 208, 148, 206, 143, 150, 219, 189, 241, 210, 19, 92, 131, 56, 70, 64, + 30, 66, 182, 163, 195, 72, 126, 110, 107, 58, 40, 84, 250, 133, 186, 61, + 202, 94, 155, 159, 10, 21, 121, 43, 78, 212, 229, 172, 115, 243, 167, 87, + 7, 112, 192, 247, 140, 128, 99, 13, 103, 74, 222, 237, 49, 197, 254, 24, + 227, 165, 153, 119, 38, 184, 180, 124, 17, 68, 146, 217, 35, 32, 137, 46, + 55, 63, 209, 91, 149, 188, 207, 205, 144, 135, 151, 178, 220, 252, 190, 97, + 242, 86, 211, 171, 20, 42, 93, 158, 132, 60, 57, 83, 71, 109, 65, 162, + 31, 45, 67, 216, 183, 123, 164, 118, 196, 23, 73, 236, 127, 12, 111, 246, + 108, 161, 59, 82, 41, 157, 85, 170, 251, 96, 134, 177, 187, 204, 62, 90, + 203, 89, 95, 176, 156, 169, 160, 81, 11, 245, 22, 235, 122, 117, 44, 215, + 79, 174, 213, 233, 230, 231, 173, 232, 116, 214, 244, 234, 168, 80, 88, 175, + ]; + + private const expTable = [ + 1, 2, 4, 8, 16, 32, 64, 128, 29, 58, 116, 232, 205, 135, 19, 38, + 76, 152, 45, 90, 180, 117, 234, 201, 143, 3, 6, 12, 24, 48, 96, 192, + 157, 39, 78, 156, 37, 74, 148, 53, 106, 212, 181, 119, 238, 193, 159, 35, + 70, 140, 5, 10, 20, 40, 80, 160, 93, 186, 105, 210, 185, 111, 222, 161, + 95, 190, 97, 194, 153, 47, 94, 188, 101, 202, 137, 15, 30, 60, 120, 240, + 253, 231, 211, 187, 107, 214, 177, 127, 254, 225, 223, 163, 91, 182, 113, 226, + 217, 175, 67, 134, 17, 34, 68, 136, 13, 26, 52, 104, 208, 189, 103, 206, + 129, 31, 62, 124, 248, 237, 199, 147, 59, 118, 236, 197, 151, 51, 102, 204, + 133, 23, 46, 92, 184, 109, 218, 169, 79, 158, 33, 66, 132, 21, 42, 84, + 168, 77, 154, 41, 82, 164, 85, 170, 73, 146, 57, 114, 228, 213, 183, 115, + 230, 209, 191, 99, 198, 145, 63, 126, 252, 229, 215, 179, 123, 246, 241, 255, + 227, 219, 171, 75, 150, 49, 98, 196, 149, 55, 110, 220, 165, 87, 174, 65, + 130, 25, 50, 100, 200, 141, 7, 14, 28, 56, 112, 224, 221, 167, 83, 166, + 81, 162, 89, 178, 121, 242, 249, 239, 195, 155, 43, 86, 172, 69, 138, 9, + 18, 36, 72, 144, 61, 122, 244, 245, 247, 243, 251, 235, 203, 139, 11, 22, + 44, 88, 176, 125, 250, 233, 207, 131, 27, 54, 108, 216, 173, 71, 142, 1, + ]; + + /** + * Implements both addition and subtraction -- they are the same in GF(size). + * + * @return int sum/difference of a and b + */ + public static function addOrSubtract(int $a, int $b):int{ + return $a ^ $b; + } + + /** + * @return GenericGFPoly the monomial representing coefficient * x^degree + */ + public static function buildMonomial(int $degree, int $coefficient):GenericGFPoly{ + + if($degree < 0){ + throw new InvalidArgumentException(); + } + + $coefficients = array_fill(0, $degree + 1, 0); + $coefficients[0] = $coefficient; + + return new GenericGFPoly($coefficients); + } + + /** + * @return int 2 to the power of a in GF(size) + */ + public static function exp(int $a):int{ + + if($a < 0){ + $a += 255; + } + elseif($a >= 256){ + $a -= 255; + } + + return self::expTable[$a]; + } + + /** + * @return int base 2 log of a in GF(size) + */ + public static function log(int $a):int{ + + if($a < 1){ + throw new InvalidArgumentException(); + } + + return self::logTable[$a]; + } + + /** + * @return int multiplicative inverse of a + */ + public static function inverse(int $a):int{ + + if($a === 0){ + throw new InvalidArgumentException(); + } + + return self::expTable[256 - self::logTable[$a] - 1]; + } + + /** + * @return int product of a and b in GF(size) + */ + public static function multiply(int $a, int $b):int{ + + if($a === 0 || $b === 0){ + return 0; + } + + return self::expTable[(self::logTable[$a] + self::logTable[$b]) % 255]; + } + +} diff --git a/src/Common/GenericGFPoly.php b/src/Common/GenericGFPoly.php new file mode 100644 index 000000000..29078b672 --- /dev/null +++ b/src/Common/GenericGFPoly.php @@ -0,0 +1,278 @@ + + * @copyright 2021 Smiley + * @license Apache-2.0 + */ + +namespace chillerlan\QRCode\Common; + +use InvalidArgumentException; + +use function array_fill, array_slice, array_splice, count; + +/** + *

Represents a polynomial whose coefficients are elements of a GF. + * Instances of this class are immutable.

+ * + *

Much credit is due to William Rucklidge since portions of this code are an indirect + * port of his C++ Reed-Solomon implementation.

+ * + * @author Sean Owen + */ +final class GenericGFPoly{ + + private array $coefficients; + + /** + * @param array|null $coefficients array coefficients as ints representing elements of GF(size), arranged + * from most significant (highest-power term) coefficient to least significant + * @param int|null $degree + * + * @throws \InvalidArgumentException if argument is null or empty, or if leading coefficient is 0 and this is not a + * constant polynomial (that is, it is not the monomial "0") + */ + public function __construct(array $coefficients, int $degree = null){ + $degree ??= 0; + + if(empty($coefficients)){ + throw new InvalidArgumentException('arg $coefficients is empty'); + } + + if($degree < 0){ + throw new InvalidArgumentException('negative degree'); + } + + $coefficientsLength = count($coefficients); + + // Leading term must be non-zero for anything except the constant polynomial "0" + $firstNonZero = 0; + + while($firstNonZero < $coefficientsLength && $coefficients[$firstNonZero] === 0){ + $firstNonZero++; + } + + if($firstNonZero === $coefficientsLength){ + $this->coefficients = [0]; + } + else{ + $this->coefficients = array_fill(0, $coefficientsLength - $firstNonZero + $degree, 0); + + for($i = 0; $i < $coefficientsLength - $firstNonZero; $i++){ + $this->coefficients[$i] = $coefficients[$i + $firstNonZero]; + } + } + } + + /** + * @return int $coefficient of x^degree term in this polynomial + */ + public function getCoefficient(int $degree):int{ + return $this->coefficients[count($this->coefficients) - 1 - $degree]; + } + + /** + * @return int[] + */ + public function getCoefficients():array{ + return $this->coefficients; + } + + /** + * @return int $degree of this polynomial + */ + public function getDegree():int{ + return count($this->coefficients) - 1; + } + + /** + * @return bool true if this polynomial is the monomial "0" + */ + public function isZero():bool{ + return $this->coefficients[0] === 0; + } + + /** + * @return int evaluation of this polynomial at a given point + */ + public function evaluateAt(int $a):int{ + + if($a === 0){ + // Just return the x^0 coefficient + return $this->getCoefficient(0); + } + + $result = 0; + + foreach($this->coefficients as $c){ + // if $a === 1 just the sum of the coefficients + $result = GF256::addOrSubtract(($a === 1 ? $result : GF256::multiply($a, $result)), $c); + } + + return $result; + } + + /** + * @param \chillerlan\QRCode\Common\GenericGFPoly $other + * + * @return \chillerlan\QRCode\Common\GenericGFPoly + */ + public function multiply(GenericGFPoly $other):GenericGFPoly{ + + if($this->isZero() || $other->isZero()){ + return new self([0]); + } + + $product = array_fill(0, count($this->coefficients) + count($other->coefficients) - 1, 0); + + foreach($this->coefficients as $i => $aCoeff){ + foreach($other->coefficients as $j => $bCoeff){ + $product[$i + $j] ^= GF256::multiply($aCoeff, $bCoeff); + } + } + + return new self($product); + } + + /** + * @param \chillerlan\QRCode\Common\GenericGFPoly $other + * + * @return \chillerlan\QRCode\Common\GenericGFPoly[] [quotient, remainder] + */ + public function divide(GenericGFPoly $other):array{ + + if($other->isZero()){ + throw new InvalidArgumentException('Division by 0'); + } + + $quotient = new self([0]); + $remainder = clone $this; + + $denominatorLeadingTerm = $other->getCoefficient($other->getDegree()); + $inverseDenominatorLeadingTerm = GF256::inverse($denominatorLeadingTerm); + + while($remainder->getDegree() >= $other->getDegree() && !$remainder->isZero()){ + $scale = GF256::multiply($remainder->getCoefficient($remainder->getDegree()), $inverseDenominatorLeadingTerm); + $diff = $remainder->getDegree() - $other->getDegree(); + $quotient = $quotient->addOrSubtract(GF256::buildMonomial($diff, $scale)); + $remainder = $remainder->addOrSubtract($other->multiplyByMonomial($diff, $scale)); + } + + return [$quotient, $remainder]; + + } + + /** + * @param int $scalar + * + * @return \chillerlan\QRCode\Common\GenericGFPoly + */ + public function multiplyInt(int $scalar):GenericGFPoly{ + + if($scalar === 0){ + return new self([0]); + } + + if($scalar === 1){ + return $this; + } + + $product = array_fill(0, count($this->coefficients), 0); + + foreach($this->coefficients as $i => $c){ + $product[$i] = GF256::multiply($c, $scalar); + } + + return new self($product); + } + + /** + * @param int $degree + * @param int $coefficient + * + * @return \chillerlan\QRCode\Common\GenericGFPoly + */ + public function multiplyByMonomial(int $degree, int $coefficient):GenericGFPoly{ + + if($degree < 0){ + throw new InvalidArgumentException(); + } + + if($coefficient === 0){ + return new self([0]); + } + + $product = array_fill(0, count($this->coefficients) + $degree, 0); + + foreach($this->coefficients as $i => $c){ + $product[$i] = GF256::multiply($c, $coefficient); + } + + return new self($product); + } + + /** + * @param \chillerlan\QRCode\Common\GenericGFPoly $other + * + * @return \chillerlan\QRCode\Common\GenericGFPoly + */ + public function mod(GenericGFPoly $other):GenericGFPoly{ + + if(count($this->coefficients) - count($other->coefficients) < 0){ + return $this; + } + + $ratio = GF256::log($this->coefficients[0]) - GF256::log($other->coefficients[0]); + + foreach($other->coefficients as $i => $c){ + $this->coefficients[$i] ^= GF256::exp(GF256::log($c) + $ratio); + } + + return (new self($this->coefficients))->mod($other); + } + + /** + * @param \chillerlan\QRCode\Common\GenericGFPoly $other + * + * @return \chillerlan\QRCode\Common\GenericGFPoly + */ + public function addOrSubtract(GenericGFPoly $other):GenericGFPoly{ + + if($this->isZero()){ + return $other; + } + + if($other->isZero()){ + return $this; + } + + $smallerCoefficients = $this->coefficients; + $largerCoefficients = $other->coefficients; + + if(count($smallerCoefficients) > count($largerCoefficients)){ + $temp = $smallerCoefficients; + $smallerCoefficients = $largerCoefficients; + $largerCoefficients = $temp; + } + + $sumDiff = array_fill(0, count($largerCoefficients), 0); + $lengthDiff = count($largerCoefficients) - count($smallerCoefficients); + // Copy high-order terms only found in higher-degree polynomial's coefficients + array_splice($sumDiff, 0, $lengthDiff, array_slice($largerCoefficients, 0, $lengthDiff)); + + $countLargerCoefficients = count($largerCoefficients); + + for($i = $lengthDiff; $i < $countLargerCoefficients; $i++){ + $sumDiff[$i] = GF256::addOrSubtract($smallerCoefficients[$i - $lengthDiff], $largerCoefficients[$i]); + } + + return new self($sumDiff); + } + +}