Merge pull request #132 from GenieTim/master

khanamiryan · web-flow · commit b331b0e594b2 · 2022-10-20T14:31:03.000+04:00
Next iteration of improvements
diff --git a/.gitignore b/.gitignore
@@ -2,3 +2,6 @@
 /vendor
 .idea/
 .phpunit.result.cache
+
+tests/qrcodes/private_test.png
+tests/qrcodes/private_test2.png
diff --git a/README.md b/README.md
@@ -1,4 +1,8 @@
 # QR code decoder / reader for PHP
+
+[![Tests](https://github.com/khanamiryan/php-qrcode-detector-decoder/actions/workflows/tests.yml/badge.svg)](https://github.com/khanamiryan/php-qrcode-detector-decoder/actions/workflows/tests.yml)
+[![Static Tests](https://github.com/khanamiryan/php-qrcode-detector-decoder/actions/workflows/static_tests.yml/badge.svg)](https://github.com/khanamiryan/php-qrcode-detector-decoder/actions/workflows/static_tests.yml)
+
 This is a PHP library to detect and decode QR-codes.<br />This is first and only QR code reader that works without extensions.<br />
 Ported from [ZXing library](https://github.com/zxing/zxing)
 
diff --git a/lib/Common/HybridBinarizer.php b/lib/Common/HybridBinarizer.php
@@ -146,7 +146,7 @@ private static function calculateBlackPoints(
 						// finish the rest of the rows quickly
 						for ($yy++, $offset += $width; $yy < self::$BLOCK_SIZE; $yy++, $offset += $width) {
 							for ($xx = 0; $xx < self::$BLOCK_SIZE; $xx++) {
-								$sum += ($luminances[$offset + $xx] & 0xFF);
+								$sum += (((int)$luminances[(int)round($offset + $xx)]) & 0xFF);
 							}
 						}
 					}
@@ -266,7 +266,7 @@ private static function thresholdBlock(
 		for ($y = 0, $offset = $yoffset * $stride + $xoffset; $y < self::$BLOCK_SIZE; $y++, $offset += $stride) {
 			for ($x = 0; $x < self::$BLOCK_SIZE; $x++) {
 				// Comparison needs to be <= so that black == 0 pixels are black even if the threshold is 0.
-				if (($luminances[$offset + $x] & 0xFF) <= $threshold) {
+				if (($luminances[(int)round($offset + $x)] & 0xFF) <= $threshold) {
 					$matrix->set($xoffset + $x, $yoffset + $y);
 				}
 			}
diff --git a/lib/Common/PerspectiveTransform.php b/lib/Common/PerspectiveTransform.php
@@ -173,8 +173,11 @@ public function transformPoints(array &$points, &$yValues = 0): void
 			$x = $points[$i];
 			$y = $points[$i + 1];
 			$denominator = $a13 * $x + $a23 * $y + $a33;
-			$points[$i] = ($a11 * $x + $a21 * $y + $a31) / $denominator;
-			$points[$i + 1] = ($a12 * $x + $a22 * $y + $a32) / $denominator;
+			// TODO: think what we do if $denominator == 0 (division by zero)
+			if ($denominator != 0.0) {
+				$points[$i] = ($a11 * $x + $a21 * $y + $a31) / $denominator;
+				$points[$i + 1] = ($a12 * $x + $a22 * $y + $a32) / $denominator;
+			}
 		}
 	}
 
diff --git a/lib/IMagickLuminanceSource.php b/lib/IMagickLuminanceSource.php
@@ -98,7 +98,7 @@ public function _IMagickLuminanceSource(\Imagick $image, $width, $height): void
 
 		$image->setImageColorspace(\Imagick::COLORSPACE_GRAY);
 		// Check that we actually have enough space to do it
-		if ($width * $height * 16 * 3 > $this->kmgStringToBytes(ini_get('memory_limit'))) {
+		if (ini_get('memory_limit') != -1 && $width * $height * 16 * 3 > $this->kmgStringToBytes(ini_get('memory_limit'))) {
 			throw new \RuntimeException("PHP Memory Limit does not allow pixel export.");
 		}
 		$pixels = $image->exportImagePixels(1, 1, $width, $height, "RGB", \Imagick::PIXEL_CHAR);
diff --git a/lib/Qrcode/Decoder/BitMatrixParser.php b/lib/Qrcode/Decoder/BitMatrixParser.php
@@ -42,7 +42,7 @@ public function __construct($bitMatrix)
 	{
 		$dimension = $bitMatrix->getHeight();
 		if ($dimension < 21 || ($dimension & 0x03) != 1) {
-			throw FormatException::getFormatInstance();
+			throw new FormatException();
 		}
 		$this->bitMatrix = $bitMatrix;
 	}
@@ -108,7 +108,7 @@ public function readCodewords()
 			$readingUp ^= true; // readingUp = !readingUp; // switch directions
 		}
 		if ($resultOffset != $version->getTotalCodewords()) {
-			throw FormatException::getFormatInstance();
+			throw new FormatException();
 		}
 
 		return $result;
@@ -156,7 +156,7 @@ public function readFormatInformation()
 		if ($parsedFormatInfo != null) {
 			return $parsedFormatInfo;
 		}
-		throw FormatException::getFormatInstance();
+		throw new FormatException();
 	}
 
 	/**
@@ -221,7 +221,7 @@ public function readVersion()
 
 			return $theParsedVersion;
 		}
-		throw FormatException::getFormatInstance("both version information locations cannot be parsed as the valid encoding of version information");
+		throw new FormatException("both version information locations cannot be parsed as the valid encoding of version information");
 	}
 
 	/**
diff --git a/lib/Qrcode/Decoder/DecodedBitStreamParser.php b/lib/Qrcode/Decoder/DecodedBitStreamParser.php
@@ -77,7 +77,7 @@ public static function decode(
 						$fc1InEffect = true;
 					} elseif ($mode == Mode::$STRUCTURED_APPEND) {
 						if ($bits->available() < 16) {
-							throw FormatException::getFormatInstance("Bits available < 16");
+							throw new FormatException("Bits available < 16");
 						}
 						// sequence number and parity is added later to the result metadata
 						// Read next 8 bits (symbol sequence #) and 8 bits (parity data), then continue
@@ -88,7 +88,7 @@ public static function decode(
 						$value = self::parseECIValue($bits);
 						$currentCharacterSetECI = CharacterSetECI::getCharacterSetECIByValue($value);
 						if ($currentCharacterSetECI == null) {
-							throw FormatException::getFormatInstance("Current character set ECI is null");
+							throw new FormatException("Current character set ECI is null");
 						}
 					} else {
 						// First handle Hanzi mode which does not start with character count
@@ -112,15 +112,15 @@ public static function decode(
 							} elseif ($mode == Mode::$KANJI) {
 								self::decodeKanjiSegment($bits, $result, $count);
 							} else {
-								throw FormatException::getFormatInstance("Unknown mode $mode to decode");
+								throw new FormatException("Unknown mode $mode to decode");
 							}
 						}
 					}
 				}
 			} while ($mode != Mode::$TERMINATOR);
 		} catch (\InvalidArgumentException $e) {
 			// from readBits() calls
-			throw FormatException::getFormatInstance("Invalid argument exception when formatting: " . $e->getMessage());
+			throw new FormatException("Invalid argument exception when formatting: " . $e->getMessage());
 		}
 
 		return new DecoderResult(
@@ -152,7 +152,7 @@ private static function parseECIValue(BitSource $bits): int
 
 			return (($firstByte & 0x1F) << 16) | $secondThirdBytes;
 		}
-		throw FormatException::getFormatInstance("ECI Value parsing failed.");
+		throw new FormatException("ECI Value parsing failed.");
 	}
 
 	/**
@@ -167,7 +167,7 @@ private static function decodeHanziSegment(
 	): void {
 		// Don't crash trying to read more bits than we have available.
 		if ($count * 13 > $bits->available()) {
-			throw FormatException::getFormatInstance("Trying to read more bits than we have available");
+			throw new FormatException("Trying to read more bits than we have available");
 		}
 
 		// Each character will require 2 bytes. Read the characters as 2-byte pairs
@@ -202,36 +202,36 @@ private static function decodeNumericSegment(
 		while ($count >= 3) {
 			// Each 10 bits encodes three digits
 			if ($bits->available() < 10) {
-				throw FormatException::getFormatInstance("Not enough bits available");
+				throw new FormatException("Not enough bits available");
 			}
 			$threeDigitsBits = $bits->readBits(10);
 			if ($threeDigitsBits >= 1000) {
-				throw FormatException::getFormatInstance("Too many three digit bits");
+				throw new FormatException("Too many three digit bits");
 			}
 			$result .= (self::toAlphaNumericChar($threeDigitsBits / 100));
-			$result .= (self::toAlphaNumericChar(($threeDigitsBits / 10) % 10));
+			$result .= (self::toAlphaNumericChar(((int)round($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("Two digits left over to read, encoded in 7 bits, but only " . $bits->available() . ' bits available');
+				throw new FormatException("Two digits left over to read, encoded in 7 bits, but only " . $bits->available() . ' bits available');
 			}
 			$twoDigitsBits = $bits->readBits(7);
 			if ($twoDigitsBits >= 100) {
-				throw FormatException::getFormatInstance("Too many bits: $twoDigitsBits expected < 100");
+				throw new FormatException("Too many bits: $twoDigitsBits expected < 100");
 			}
 			$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("One digit left to read, but < 4 bits available");
+				throw new FormatException("One digit left to read, but < 4 bits available");
 			}
 			$digitBits = $bits->readBits(4);
 			if ($digitBits >= 10) {
-				throw FormatException::getFormatInstance("Too many bits: $digitBits expected < 10");
+				throw new FormatException("Too many bits: $digitBits expected < 10");
 			}
 			$result .= (self::toAlphaNumericChar($digitBits));
 		}
@@ -242,11 +242,12 @@ private static function decodeNumericSegment(
 	 */
 	private static function toAlphaNumericChar(int|float $value)
 	{
-		if ($value >= count(self::$ALPHANUMERIC_CHARS)) {
-			throw FormatException::getFormatInstance("$value has too many alphanumeric chars");
+		$intVal = (int) $value;
+		if ($intVal >= count(self::$ALPHANUMERIC_CHARS)) {
+			throw new FormatException("$intVal is too many alphanumeric chars");
 		}
 
-		return self::$ALPHANUMERIC_CHARS[$value];
+		return self::$ALPHANUMERIC_CHARS[(int)($intVal)];
 	}
 
 	private static function decodeAlphanumericSegment(
@@ -259,7 +260,7 @@ private static function decodeAlphanumericSegment(
 		$start = strlen((string) $result);
 		while ($count > 1) {
 			if ($bits->available() < 11) {
-				throw FormatException::getFormatInstance("Not enough bits available to read two expected characters");
+				throw new FormatException("Not enough bits available to read two expected characters");
 			}
 			$nextTwoCharsBits = $bits->readBits(11);
 			$result .= (self::toAlphaNumericChar($nextTwoCharsBits / 45));
@@ -269,7 +270,7 @@ private static function decodeAlphanumericSegment(
 		if ($count == 1) {
 			// special case: one character left
 			if ($bits->available() < 6) {
-				throw FormatException::getFormatInstance("Not enough bits available to read one expected character");
+				throw new FormatException("Not enough bits available to read one expected character");
 			}
 			$result .= self::toAlphaNumericChar($bits->readBits(6));
 		}
@@ -300,7 +301,7 @@ private static function decodeByteSegment(
 	): void {
 		// Don't crash trying to read more bits than we have available.
 		if (8 * $count > $bits->available()) {
-			throw FormatException::getFormatInstance("Trying to read more bits than we have available");
+			throw new FormatException("Trying to read more bits than we have available");
 		}
 
 		$readBytes = fill_array(0, $count, 0);
@@ -337,7 +338,7 @@ private static function decodeKanjiSegment(
 	): void {
 		// Don't crash trying to read more bits than we have available.
 		if ($count * 13 > $bits->available()) {
-			throw FormatException::getFormatInstance("Trying to read more bits than we have available");
+			throw new FormatException("Trying to read more bits than we have available");
 		}
 
 		// Each character will require 2 bytes. Read the characters as 2-byte pairs
diff --git a/lib/Qrcode/Decoder/Version.php b/lib/Qrcode/Decoder/Version.php
@@ -100,12 +100,12 @@ public function getECBlocksForLevel(ErrorCorrectionLevel $ecLevel)
 	public static function getProvisionalVersionForDimension($dimension)
 	{
 		if ($dimension % 4 != 1) {
-			throw FormatException::getFormatInstance();
+			throw new FormatException();
 		}
 		try {
 			return self::getVersionForNumber(($dimension - 17) / 4);
 		} catch (\InvalidArgumentException) {
-			throw FormatException::getFormatInstance();
+			throw new FormatException();
 		}
 	}
 
diff --git a/lib/Qrcode/Detector/FinderPatternFinder.php b/lib/Qrcode/Detector/FinderPatternFinder.php
@@ -58,6 +58,8 @@ final public function find(array|null $hints): \Zxing\Qrcode\Detector\FinderPatt
 		$tryHarder = $hints != null && array_key_exists('TRY_HARDER', $hints) && $hints['TRY_HARDER'];
 		$pureBarcode = $hints != null && array_key_exists('PURE_BARCODE', $hints) && $hints['PURE_BARCODE'];
 		$nrOfRowsSkippable = $hints != null && array_key_exists('NR_ALLOW_SKIP_ROWS', $hints) ? $hints['NR_ALLOW_SKIP_ROWS'] : ($tryHarder ? 0 : null);
+		$allowedDeviation = $hints != null && array_key_exists('ALLOWED_DEVIATION', $hints) ? $hints['ALLOWED_DEVIATION'] : 0.05;
+		$maxVariance = $hints != null && array_key_exists('MAX_VARIANCE', $hints) ? $hints['MAX_VARIANCE'] : 0.5;
 		$maxI = $this->image->getHeight();
 		$maxJ = $this->image->getWidth();
 		// We are looking for black/white/black/white/black modules in
@@ -92,14 +94,14 @@ final public function find(array|null $hints): \Zxing\Qrcode\Detector\FinderPatt
 				} else { // White pixel
 					if (($currentState & 1) == 0) { // Counting black pixels
 						if ($currentState == 4) { // A winner?
-							if (self::foundPatternCross($stateCount)) { // Yes
+							if (self::foundPatternCross($stateCount, $maxVariance)) { // 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();
+										$done = $this->haveMultiplyConfirmedCenters($allowedDeviation);
 									} else {
 										$rowSkip = $nrOfRowsSkippable === null ? $this->findRowSkip() : $nrOfRowsSkippable;
 										if ($rowSkip > $stateCount[2]) {
@@ -147,13 +149,13 @@ final public function find(array|null $hints): \Zxing\Qrcode\Detector\FinderPatt
 					}
 				}
 			}
-			if (self::foundPatternCross($stateCount)) {
+			if (self::foundPatternCross($stateCount, $maxVariance)) {
 				$confirmed = $this->handlePossibleCenter($stateCount, $i, $maxJ, $pureBarcode);
 				if ($confirmed) {
 					$iSkip = $stateCount[0];
 					if ($this->hasSkipped) {
 						// Found a third one
-						$done = $this->haveMultiplyConfirmedCenters();
+						$done = $this->haveMultiplyConfirmedCenters($allowedDeviation);
 					}
 				}
 			}
@@ -173,7 +175,7 @@ final public function find(array|null $hints): \Zxing\Qrcode\Detector\FinderPatt
 	 *
 	 * @psalm-param array<0|positive-int, int> $stateCount
 	 */
-	protected static function foundPatternCross(array $stateCount): bool
+	protected static function foundPatternCross(array $stateCount, float $maxVariance = 0.5): bool
 	{
 		$totalModuleSize = 0;
 		for ($i = 0; $i < 5; $i++) {
@@ -187,7 +189,7 @@ protected static function foundPatternCross(array $stateCount): bool
 			return false;
 		}
 		$moduleSize = $totalModuleSize / 7.0;
-		$maxVariance = $moduleSize / 2.0;
+		$maxVariance = $moduleSize * $maxVariance;
 
 		// Allow less than 50% variance from 1-1-3-1-1 proportions
 		return
@@ -537,7 +539,7 @@ private function crossCheckDiagonal(int $startI, int $centerJ, $maxCount, int|fl
 	/**
 	 * @return bool 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(): bool
+	private function haveMultiplyConfirmedCenters(?float $allowedDeviation = 0.05): bool
 	{
 		$confirmedCount = 0;
 		$totalModuleSize = 0.0;
@@ -561,7 +563,7 @@ private function haveMultiplyConfirmedCenters(): bool
 			$totalDeviation += abs($pattern->getEstimatedModuleSize() - $average);
 		}
 
-		return $totalDeviation <= 0.05 * $totalModuleSize;
+		return $totalDeviation <= $allowedDeviation * $totalModuleSize;
 	}
 
 	/**
@@ -609,7 +611,7 @@ private function selectBestPatterns()
 		$startSize = count($this->possibleCenters);
 		if ($startSize < 3) {
 			// Couldn't find enough finder patterns
-			throw new NotFoundException();
+			throw new NotFoundException("Could not find 3 finder patterns ($startSize found)");
 		}
 
 		// Filter outlier possibilities whose module size is too different
diff --git a/tests/QrReaderTest.php b/tests/QrReaderTest.php
@@ -11,7 +11,7 @@ class QrReaderTest extends TestCase
 	public function setUp(): void
 	{
 		error_reporting(E_ALL);
-		ini_set('memory_limit','2G');
+		ini_set('memory_limit', '2G');
 	}
 
 	public function testText1()
@@ -54,4 +54,19 @@ public function testText3()
 		$this->assertSame(null, $qrcode->getError());
 		$this->assertSame("https://www.gosuslugi.ru/covid-cert/verify/9770000014233333?lang=ru&ck=733a9d218d312fe134f1c2cc06e1a800", $qrcode->text());
 	}
+
+	// TODO: fix this test
+	// public function testText4()
+	// {
+	// 	$image = __DIR__ . "/qrcodes/174419877-f6b5dae1-2251-4b67-95f1-5e1143e40fae.jpg";
+	// 	$qrcode = new QrReader($image);
+	// 	$qrcode->decode([
+	// 		'TRY_HARDER' => true,
+	// 		'NR_ALLOW_SKIP_ROWS' => 0,
+	// 		// 'ALLOWED_DEVIATION' => 0.1,
+	// 		// 'MAX_VARIANCE' => 0.7
+	// 	]);
+	// 	$this->assertSame(null, $qrcode->getError());
+	// 	$this->assertSame("some text", $qrcode->text());
+	// }
 }
diff --git a/tests/qrcodes/174419877-f6b5dae1-2251-4b67-95f1-5e1143e40fae.jpg b/tests/qrcodes/174419877-f6b5dae1-2251-4b67-95f1-5e1143e40fae.jpg

Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ private static function calculateBlackPoints(`
`146`	`146`	`// finish the rest of the rows quickly`
`147`	`147`	`for ($yy++, $offset += $width; $yy < self::$BLOCK_SIZE; $yy++, $offset += $width) {`
`148`	`148`	`for ($xx = 0; $xx < self::$BLOCK_SIZE; $xx++) {`
`149`		`- $sum += ($luminances[$offset + $xx] & 0xFF);`
	`149`	`+ $sum += (((int)$luminances[(int)round($offset + $xx)]) & 0xFF);`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`	`}`
`@@ -266,7 +266,7 @@ private static function thresholdBlock(`
`266`	`266`	`for ($y = 0, $offset = $yoffset * $stride + $xoffset; $y < self::$BLOCK_SIZE; $y++, $offset += $stride) {`
`267`	`267`	`for ($x = 0; $x < self::$BLOCK_SIZE; $x++) {`
`268`	`268`	`// Comparison needs to be <= so that black == 0 pixels are black even if the threshold is 0.`
`269`		`- if (($luminances[$offset + $x] & 0xFF) <= $threshold) {`
	`269`	`+ if (($luminances[(int)round($offset + $x)] & 0xFF) <= $threshold) {`
`270`	`270`	`$matrix->set($xoffset + $x, $yoffset + $y);`
`271`	`271`	`}`
`272`	`272`	`}`
Original file line number	Diff line number	Diff line change
`@@ -173,8 +173,11 @@ public function transformPoints(array &$points, &$yValues = 0): void`
`173`	`173`	`$x = $points[$i];`
`174`	`174`	`$y = $points[$i + 1];`
`175`	`175`	`$denominator = $a13 * $x + $a23 * $y + $a33;`
`176`		`- $points[$i] = ($a11 * $x + $a21 * $y + $a31) / $denominator;`
`177`		`- $points[$i + 1] = ($a12 * $x + $a22 * $y + $a32) / $denominator;`
	`176`	`+ // TODO: think what we do if $denominator == 0 (division by zero)`
	`177`	`+ if ($denominator != 0.0) {`
	`178`	`+ $points[$i] = ($a11 * $x + $a21 * $y + $a31) / $denominator;`
	`179`	`+ $points[$i + 1] = ($a12 * $x + $a22 * $y + $a32) / $denominator;`
	`180`	`+ }`
`178`	`181`	`}`
`179`	`182`	`}`
`180`	`183`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ public function _IMagickLuminanceSource(\Imagick $image, $width, $height): void`
`98`	`98`
`99`	`99`	`$image->setImageColorspace(\Imagick::COLORSPACE_GRAY);`
`100`	`100`	`// Check that we actually have enough space to do it`
`101`		`- if ($width * $height * 16 * 3 > $this->kmgStringToBytes(ini_get('memory_limit'))) {`
	`101`	`+ if (ini_get('memory_limit') != -1 && $width * $height * 16 * 3 > $this->kmgStringToBytes(ini_get('memory_limit'))) {`
`102`	`102`	`throw new \RuntimeException("PHP Memory Limit does not allow pixel export.");`
`103`	`103`	`}`
`104`	`104`	`$pixels = $image->exportImagePixels(1, 1, $width, $height, "RGB", \Imagick::PIXEL_CHAR);`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public function __construct($bitMatrix)`
`42`	`42`	`{`
`43`	`43`	`$dimension = $bitMatrix->getHeight();`
`44`	`44`	`if ($dimension < 21 \|\| ($dimension & 0x03) != 1) {`
`45`		`- throw FormatException::getFormatInstance();`
	`45`	`+ throw new FormatException();`
`46`	`46`	`}`
`47`	`47`	`$this->bitMatrix = $bitMatrix;`
`48`	`48`	`}`
`@@ -108,7 +108,7 @@ public function readCodewords()`
`108`	`108`	`$readingUp ^= true; // readingUp = !readingUp; // switch directions`
`109`	`109`	`}`
`110`	`110`	`if ($resultOffset != $version->getTotalCodewords()) {`
`111`		`- throw FormatException::getFormatInstance();`
	`111`	`+ throw new FormatException();`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`return $result;`
`@@ -156,7 +156,7 @@ public function readFormatInformation()`
`156`	`156`	`if ($parsedFormatInfo != null) {`
`157`	`157`	`return $parsedFormatInfo;`
`158`	`158`	`}`
`159`		`- throw FormatException::getFormatInstance();`
	`159`	`+ throw new FormatException();`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`/**`
`@@ -221,7 +221,7 @@ public function readVersion()`
`221`	`221`
`222`	`222`	`return $theParsedVersion;`
`223`	`223`	`}`
`224`		`- throw FormatException::getFormatInstance("both version information locations cannot be parsed as the valid encoding of version information");`
	`224`	`+ throw new FormatException("both version information locations cannot be parsed as the valid encoding of version information");`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ public static function decode(`
`77`	`77`	`$fc1InEffect = true;`
`78`	`78`	`} elseif ($mode == Mode::$STRUCTURED_APPEND) {`
`79`	`79`	`if ($bits->available() < 16) {`
`80`		`- throw FormatException::getFormatInstance("Bits available < 16");`
	`80`	`+ throw new FormatException("Bits available < 16");`
`81`	`81`	`}`
`82`	`82`	`// sequence number and parity is added later to the result metadata`
`83`	`83`	`// Read next 8 bits (symbol sequence #) and 8 bits (parity data), then continue`
`@@ -88,7 +88,7 @@ public static function decode(`
`88`	`88`	`$value = self::parseECIValue($bits);`
`89`	`89`	`$currentCharacterSetECI = CharacterSetECI::getCharacterSetECIByValue($value);`
`90`	`90`	`if ($currentCharacterSetECI == null) {`
`91`		`- throw FormatException::getFormatInstance("Current character set ECI is null");`
	`91`	`+ throw new FormatException("Current character set ECI is null");`
`92`	`92`	`}`
`93`	`93`	`} else {`
`94`	`94`	`// First handle Hanzi mode which does not start with character count`
`@@ -112,15 +112,15 @@ public static function decode(`
`112`	`112`	`} elseif ($mode == Mode::$KANJI) {`
`113`	`113`	`self::decodeKanjiSegment($bits, $result, $count);`
`114`	`114`	`} else {`
`115`		`- throw FormatException::getFormatInstance("Unknown mode $mode to decode");`
	`115`	`+ throw new FormatException("Unknown mode $mode to decode");`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`	`} while ($mode != Mode::$TERMINATOR);`
`121`	`121`	`} catch (\InvalidArgumentException $e) {`
`122`	`122`	`// from readBits() calls`
`123`		`- throw FormatException::getFormatInstance("Invalid argument exception when formatting: " . $e->getMessage());`
	`123`	`+ throw new FormatException("Invalid argument exception when formatting: " . $e->getMessage());`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`return new DecoderResult(`
`@@ -152,7 +152,7 @@ private static function parseECIValue(BitSource $bits): int`
`152`	`152`
`153`	`153`	`return (($firstByte & 0x1F) << 16) \| $secondThirdBytes;`
`154`	`154`	`}`
`155`		`- throw FormatException::getFormatInstance("ECI Value parsing failed.");`
	`155`	`+ throw new FormatException("ECI Value parsing failed.");`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`/**`
`@@ -167,7 +167,7 @@ private static function decodeHanziSegment(`
`167`	`167`	`): void {`
`168`	`168`	`// Don't crash trying to read more bits than we have available.`
`169`	`169`	`if ($count * 13 > $bits->available()) {`
`170`		`- throw FormatException::getFormatInstance("Trying to read more bits than we have available");`
	`170`	`+ throw new FormatException("Trying to read more bits than we have available");`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`// Each character will require 2 bytes. Read the characters as 2-byte pairs`
`@@ -202,36 +202,36 @@ private static function decodeNumericSegment(`
`202`	`202`	`while ($count >= 3) {`
`203`	`203`	`// Each 10 bits encodes three digits`
`204`	`204`	`if ($bits->available() < 10) {`
`205`		`- throw FormatException::getFormatInstance("Not enough bits available");`
	`205`	`+ throw new FormatException("Not enough bits available");`
`206`	`206`	`}`
`207`	`207`	`$threeDigitsBits = $bits->readBits(10);`
`208`	`208`	`if ($threeDigitsBits >= 1000) {`
`209`		`- throw FormatException::getFormatInstance("Too many three digit bits");`
	`209`	`+ throw new FormatException("Too many three digit bits");`
`210`	`210`	`}`
`211`	`211`	`$result .= (self::toAlphaNumericChar($threeDigitsBits / 100));`
`212`		`- $result .= (self::toAlphaNumericChar(($threeDigitsBits / 10) % 10));`
	`212`	`+ $result .= (self::toAlphaNumericChar(((int)round($threeDigitsBits / 10)) % 10));`
`213`	`213`	`$result .= (self::toAlphaNumericChar($threeDigitsBits % 10));`
`214`	`214`	`$count -= 3;`
`215`	`215`	`}`
`216`	`216`	`if ($count == 2) {`
`217`	`217`	`// Two digits left over to read, encoded in 7 bits`
`218`	`218`	`if ($bits->available() < 7) {`
`219`		`- throw FormatException::getFormatInstance("Two digits left over to read, encoded in 7 bits, but only " . $bits->available() . ' bits available');`
	`219`	`+ throw new FormatException("Two digits left over to read, encoded in 7 bits, but only " . $bits->available() . ' bits available');`
`220`	`220`	`}`
`221`	`221`	`$twoDigitsBits = $bits->readBits(7);`
`222`	`222`	`if ($twoDigitsBits >= 100) {`
`223`		`- throw FormatException::getFormatInstance("Too many bits: $twoDigitsBits expected < 100");`
	`223`	`+ throw new FormatException("Too many bits: $twoDigitsBits expected < 100");`
`224`	`224`	`}`
`225`	`225`	`$result .= (self::toAlphaNumericChar($twoDigitsBits / 10));`
`226`	`226`	`$result .= (self::toAlphaNumericChar($twoDigitsBits % 10));`
`227`	`227`	`} elseif ($count == 1) {`
`228`	`228`	`// One digit left over to read`
`229`	`229`	`if ($bits->available() < 4) {`
`230`		`- throw FormatException::getFormatInstance("One digit left to read, but < 4 bits available");`
	`230`	`+ throw new FormatException("One digit left to read, but < 4 bits available");`
`231`	`231`	`}`
`232`	`232`	`$digitBits = $bits->readBits(4);`
`233`	`233`	`if ($digitBits >= 10) {`
`234`		`- throw FormatException::getFormatInstance("Too many bits: $digitBits expected < 10");`
	`234`	`+ throw new FormatException("Too many bits: $digitBits expected < 10");`
`235`	`235`	`}`
`236`	`236`	`$result .= (self::toAlphaNumericChar($digitBits));`
`237`	`237`	`}`
`@@ -242,11 +242,12 @@ private static function decodeNumericSegment(`
`242`	`242`	`*/`
`243`	`243`	`private static function toAlphaNumericChar(int\|float $value)`
`244`	`244`	`{`
`245`		`- if ($value >= count(self::$ALPHANUMERIC_CHARS)) {`
`246`		`- throw FormatException::getFormatInstance("$value has too many alphanumeric chars");`
	`245`	`+ $intVal = (int) $value;`
	`246`	`+ if ($intVal >= count(self::$ALPHANUMERIC_CHARS)) {`
	`247`	`+ throw new FormatException("$intVal is too many alphanumeric chars");`
`247`	`248`	`}`
`248`	`249`
`249`		`- return self::$ALPHANUMERIC_CHARS[$value];`
	`250`	`+ return self::$ALPHANUMERIC_CHARS[(int)($intVal)];`
`250`	`251`	`}`
`251`	`252`
`252`	`253`	`private static function decodeAlphanumericSegment(`
`@@ -259,7 +260,7 @@ private static function decodeAlphanumericSegment(`
`259`	`260`	`$start = strlen((string) $result);`
`260`	`261`	`while ($count > 1) {`
`261`	`262`	`if ($bits->available() < 11) {`
`262`		`- throw FormatException::getFormatInstance("Not enough bits available to read two expected characters");`
	`263`	`+ throw new FormatException("Not enough bits available to read two expected characters");`
`263`	`264`	`}`
`264`	`265`	`$nextTwoCharsBits = $bits->readBits(11);`
`265`	`266`	`$result .= (self::toAlphaNumericChar($nextTwoCharsBits / 45));`
`@@ -269,7 +270,7 @@ private static function decodeAlphanumericSegment(`
`269`	`270`	`if ($count == 1) {`
`270`	`271`	`// special case: one character left`
`271`	`272`	`if ($bits->available() < 6) {`
`272`		`- throw FormatException::getFormatInstance("Not enough bits available to read one expected character");`
	`273`	`+ throw new FormatException("Not enough bits available to read one expected character");`
`273`	`274`	`}`
`274`	`275`	`$result .= self::toAlphaNumericChar($bits->readBits(6));`
`275`	`276`	`}`
`@@ -300,7 +301,7 @@ private static function decodeByteSegment(`
`300`	`301`	`): void {`
`301`	`302`	`// Don't crash trying to read more bits than we have available.`
`302`	`303`	`if (8 * $count > $bits->available()) {`
`303`		`- throw FormatException::getFormatInstance("Trying to read more bits than we have available");`
	`304`	`+ throw new FormatException("Trying to read more bits than we have available");`
`304`	`305`	`}`
`305`	`306`
`306`	`307`	`$readBytes = fill_array(0, $count, 0);`
`@@ -337,7 +338,7 @@ private static function decodeKanjiSegment(`
`337`	`338`	`): void {`
`338`	`339`	`// Don't crash trying to read more bits than we have available.`
`339`	`340`	`if ($count * 13 > $bits->available()) {`
`340`		`- throw FormatException::getFormatInstance("Trying to read more bits than we have available");`
	`341`	`+ throw new FormatException("Trying to read more bits than we have available");`
`341`	`342`	`}`
`342`	`343`
`343`	`344`	`// Each character will require 2 bytes. Read the characters as 2-byte pairs`
Original file line number	Diff line number	Diff line change
`@@ -100,12 +100,12 @@ public function getECBlocksForLevel(ErrorCorrectionLevel $ecLevel)`
`100`	`100`	`public static function getProvisionalVersionForDimension($dimension)`
`101`	`101`	`{`
`102`	`102`	`if ($dimension % 4 != 1) {`
`103`		`- throw FormatException::getFormatInstance();`
	`103`	`+ throw new FormatException();`
`104`	`104`	`}`
`105`	`105`	`try {`
`106`	`106`	`return self::getVersionForNumber(($dimension - 17) / 4);`
`107`	`107`	`} catch (\InvalidArgumentException) {`
`108`		`- throw FormatException::getFormatInstance();`
	`108`	`+ throw new FormatException();`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`