chinahu/EASYAIuniappNewUI
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2025/2/8第一次更新

Browse Source
This commit is contained in:
爱吃咸鱼小猫咪
2025-02-08 18:50:38 +08:00
commit d7af560866
26519 changed files with 5046029 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
node_modules/qrcode-reader/.editorconfig
Generated Vendored
+17
View File
@@ -0,0 +1,17 @@
# EditorConfig helps developers define and maintain consistent
# coding styles between different editors and IDEs
# editorconfig.org
root = true
[*]
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
indent_style = space
indent_size = 2
[*.{diff,md}]
trim_trailing_whitespace = false
node_modules/qrcode-reader/.eslintrc.js
Generated Vendored
+43
View File
@@ -0,0 +1,43 @@
module.exports = {
parserOptions: {
ecmaVersion: 6,
sourceType: 'module',
},
env: {
'browser': true,
'commonjs': true,
'node': true,
},
extends: 'eslint:recommended',
rules: {
'comma-dangle': 'off',
'no-console': 'off',
'no-constant-condition': 'off',
'no-redeclare': 'off',
'no-unused-vars': 'off',
'array-bracket-spacing': 'error',
'block-spacing': 'error',
'brace-style': 'error',
'comma-spacing': 'error',
'comma-style': 'error',
'eol-last': 'error',
'indent': ['error', 2],
'key-spacing': 'error',
'keyword-spacing': 'error',
'linebreak-style': 'error',
'no-array-constructor': 'error',
'no-trailing-spaces': 'error',
'no-unneeded-ternary': 'error',
'object-curly-newline': 'error',
'object-curly-spacing': 'error',
'operator-linebreak': 'error',
'semi-spacing': 'error',
'semi': 'error',
'space-before-blocks': 'error',
'space-before-function-paren': ['error', 'never'],
'space-in-parens': 'error',
'space-infix-ops': 'error',
'space-unary-ops': 'error',
},
};
node_modules/qrcode-reader/.travis.yml
Generated Vendored
+24
View File
@@ -0,0 +1,24 @@
sudo: required
language: node_js
node_js:
- "4"
- "5"
- "6"
- "7"
- "8"
before_install:
- sudo apt-get -qq update
- sudo add-apt-repository --yes ppa:dhor/myway
- sudo apt-get -qq update
- sudo apt-get install graphicsmagick
install:
- npm install
script:
- npm run build
- npm test
- npm run preversion
node_modules/qrcode-reader/CHANGELOG.md
Generated Vendored
+24
View File
@@ -0,0 +1,24 @@
Changelog
=========
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/).
1.0.4
-----
Bugfix add support for zxing qrcodes
1.0.0
-----
### Changed
- Update api to return result and bounding box : https://github.com/edi9999/jsqrcode/issues/35
- Update api to be error-first ([#30](https://github.com/edi9999/jsqrcode/pull/30)\)
0.x
---
- Initial release
node_modules/qrcode-reader/COPYING
Generated Vendored
+201
View File
@@ -0,0 +1,201 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
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.
node_modules/qrcode-reader/README.md
Generated Vendored
+162
View File
@@ -0,0 +1,162 @@
JavaScript QRCode reader for HTML5 enabled browser.
===================================================
This was started as a port of Lazarsoft’s qrcode reader.
It is a maintained fork, so feel free to open issues or PR !
[![Build Status](https://travis-ci.org/edi9999/jsqrcode.svg?branch=master&style=flat)](https://travis-ci.org/edi9999/jsqrcode)
Installation
============
```
npm install qrcode-reader
```
Usage
=====
```
var QrCode = require('qrcode-reader');
```
Create a new instance of QrCode:
```
var qr = new QrCode();
```
Set its callback to a custom function:
```
qr.callback = function(error, result) {
if(error) {
console.log(error)
return;
}
console.log(result)
}
```
Passing image data in node
==========================
You have to use an external imageparser
1. You can use `npm install --save jimp` which doesn't have any dependency (runs in pure node).
```javascript
var Jimp = require("jimp");
var buffer = fs.readFileSync(__dirname + '/image.png');
Jimp.read(buffer, function(err, image) {
if (err) {
console.error(err);
// TODO handle error
}
var qr = new QrCode();
qr.callback = function(err, value) {
if (err) {
console.error(err);
// TODO handle error
}
console.log(value.result);
console.log(value);
};
qr.decode(image.bitmap);
});
```
2. You can use `npm install --save image-parser`, which depends on lwip or graphicsmagick
```javascript
var ImageParser = require("image-parser");
var buffer = fs.readFileSync(__dirname + '/image.png');
var img = new ImageParser(img);
img.parse(function(err) {
if (err) {
console.error(err);
// TODO handle error
}
var qr = new QrCode();
qr.callback = function(err, value) {
if (err) {
console.error(err);
// TODO handle error
return done(err);
}
console.log(value.result);
console.log(value);
};
qr.decode({width: img.width(), height: img.height()}, img._imgBuffer);
});
```
Passing image data in the browser
=================================
Since the browser contains the Image global, we can use it to open images with URL, Data URI, ...
Decode an image by its URL or Data URI:
```
qr.decode(url or DataURL);
```
Decode an image by context.getImageData: Works with [web workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers).
```
var context = canvas.getContext("2d"); var data = context.getImageData(0, 0, width, height);
qr.decode(data);
```
====================
If you want, you can build the script yourself.
First clone the repository, then from the directory of this repository, do:
```
npm install
```
To run the build process and generate a JavaScript file called `dist/index.js` you can run from node:
```
npm run build
```
To run the tests:
```
npm test
```
Make it work in the browser
===========================
The generated file `dist/index.js` works in the browser.
You will have access to the global variable `QrCode` if you do the following in your HTML:
\`\`\`
<script src="dist/index.js"></script> \`\`\`
See [examples/browser-upload/index.html](examples/browser-upload/index.html) for a very basic example using a file upload.
Changelog
=========
See [`CHANGELOG.md`](CHANGELOG.md)\.
node_modules/qrcode-reader/dist/index.js
Generated Vendored
+3241
View File
File diff suppressed because it is too large Load Diff
node_modules/qrcode-reader/dist/index.js.map
Generated Vendored
+1
View File
File diff suppressed because one or more lines are too long
node_modules/qrcode-reader/dist/index.min.js
Generated Vendored
+1
View File
File diff suppressed because one or more lines are too long
node_modules/qrcode-reader/examples/browser-upload/index.html
Generated Vendored
+71
View File
@@ -0,0 +1,71 @@
<!DOCTYPE html>
<html>
<head>
<title>QR Test</title>
<style>
#preview img {
border: 1px solid black;
float: left;
margin: 0 1em 1em 0;
width: 10em;
}
</style>
</head>
<body>
<h1>Simple browser demo using the FileReader API</h1>
<h2>Upload file</h2>
<input type="file" id="upload">
<h2>Result</h2>
<div id="preview"></div>
<script type="text/javascript" src="../../dist/index.js"></script>
<script type="text/javascript">
(function() {
'use strict';
var upload = document.getElementById('upload');
var preview = document.getElementById('preview');
var qr = new QrCode();
qr.callback = function(err, result) {
var span = document.querySelector('span') || document.createElement('span');
if(result){
span.textContent = result;
}
else{
span.textContent = 'Error! See error message in console!';
console.error(err);
}
preview.appendChild(span);
}
upload.addEventListener('change', function() {
for (var i = 0; i < this.files.length; i++) {
var file = this.files[i];
var imageType = /^image\//;
if (!imageType.test(file.type)) {
throw new Error('File type not valid');
}
// Read file
var reader = new FileReader();
reader.addEventListener('load', function() {
// Show as preview image
var img = document.querySelector('img') || document.createElement('img');
img.src = this.result;
preview.appendChild(img);
// Analyse code
qr.decode(this.result);
}.bind(reader), false);
reader.readAsDataURL(file);
}
}, false);
})();
</script>
</body>
</html>
node_modules/qrcode-reader/package.json
Generated Vendored
+37
View File
@@ -0,0 +1,37 @@
{
"name": "qrcode-reader",
"version": "1.0.4",
"description": "fork of lazarsoft's jsqrcode for node",
"main": "dist/index.js",
"module": "src/index.js",
"jsnext:main": "src/index.js",
"scripts": {
"build": "rollup -c",
"watch": "rollup -c -w",
"minify": "uglifyjs dist/index.js -o dist/index.min.js --compress --mangle",
"lint": "eslint src test",
"pretest": "npm run lint",
"test": "mocha",
"build-and-test": "npm run build && npm test",
"preversion": "npm run lint && npm run build && npm run minify && npm test"
},
"repository": {
"type": "git",
"url": "https://github.com/edi9999/jsqrcode.git"
},
"author": "",
"license": "Apache-2.0",
"bugs": {
"url": "https://github.com/edi9999/jsqrcode/issues"
},
"homepage": "https://github.com/edi9999/jsqrcode",
"devDependencies": {
"chai": "^4.1.2",
"eslint": "^4.7.2",
"image-parser": "^1.2.5",
"jimp": "^0.2.28",
"mocha": "^3.5.3",
"rollup": "^0.50.0",
"uglify-js": "^3.1.2"
}
}
node_modules/qrcode-reader/rollup.config.js
Generated Vendored
+13
View File
@@ -0,0 +1,13 @@
var pkg = require('./package.json');
export default {
entry: 'src/index.js',
targets: [
{
dest: pkg['main'],
format: 'umd',
moduleName: 'QrCode',
sourceMap: true
}
]
};
node_modules/qrcode-reader/src/alignpat.js
Generated Vendored
+233
View File
@@ -0,0 +1,233 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
export default function AlignmentPattern(posX, posY, estimatedModuleSize) {
this.x = posX;
this.y = posY;
this.count = 1;
this.estimatedModuleSize = estimatedModuleSize;
}
Object.defineProperty(AlignmentPattern.prototype, "X", {
get: function() {
return Math.floor(this.x);
}
});
Object.defineProperty(AlignmentPattern.prototype, "Y", {
get: function() {
return Math.floor(this.y);
}
});
AlignmentPattern.prototype.incrementCount = function() {
this.count++;
};
AlignmentPattern.prototype.aboutEquals = function(moduleSize, i, j) {
if (Math.abs(i - this.y) <= moduleSize && Math.abs(j - this.x) <= moduleSize) {
var moduleSizeDiff = Math.abs(moduleSize - this.estimatedModuleSize);
return moduleSizeDiff <= 1.0 || moduleSizeDiff / this.estimatedModuleSize <= 1.0;
}
return false;
};
export function AlignmentPatternFinder(image, startX, startY, width, height, moduleSize, resultPointCallback) {
this.image = image;
this.possibleCenters = [];
this.startX = startX;
this.startY = startY;
this.width = width;
this.height = height;
this.moduleSize = moduleSize;
this.crossCheckStateCount = [0, 0, 0];
this.resultPointCallback = resultPointCallback;
}
AlignmentPatternFinder.prototype.centerFromEnd = function(stateCount, end) {
return (end - stateCount[2]) - stateCount[1] / 2.0;
};
AlignmentPatternFinder.prototype.foundPatternCross = function(stateCount) {
var moduleSize = this.moduleSize;
var maxVariance = moduleSize / 2.0;
for (var i = 0; i < 3; i++) {
if (Math.abs(moduleSize - stateCount[i]) >= maxVariance) {
return false;
}
}
return true;
};
AlignmentPatternFinder.prototype.crossCheckVertical = function(startI, centerJ, maxCount, originalStateCountTotal) {
var image = this.image;
var maxI = image.height;
var stateCount = this.crossCheckStateCount;
stateCount[0] = 0;
stateCount[1] = 0;
stateCount[2] = 0;
// Start counting up from center
var i = startI;
while (i >= 0 && image.data[centerJ + i * image.width] && 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.data[centerJ + i * image.width] && 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.data[centerJ + i * image.width] && stateCount[1] <= maxCount) {
stateCount[1]++;
i++;
}
if (i == maxI || stateCount[1] > maxCount) {
return NaN;
}
while (i < maxI && !image.data[centerJ + i * image.width] && stateCount[2] <= maxCount) {
stateCount[2]++;
i++;
}
if (stateCount[2] > maxCount) {
return NaN;
}
var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];
if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {
return NaN;
}
return this.foundPatternCross(stateCount) ? this.centerFromEnd(stateCount, i) : NaN;
};
AlignmentPatternFinder.prototype.handlePossibleCenter = function(stateCount, i, j) {
var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];
var centerJ = this.centerFromEnd(stateCount, j);
var centerI = this.crossCheckVertical(i, Math.floor(centerJ), 2 * stateCount[1], stateCountTotal);
if (!isNaN(centerI)) {
var estimatedModuleSize = (stateCount[0] + stateCount[1] + stateCount[2]) / 3.0;
var max = this.possibleCenters.length;
for (var index = 0; index < max; index++) {
var center = this.possibleCenters[index];
// Look for about the same center and module size:
if (center.aboutEquals(estimatedModuleSize, centerI, centerJ)) {
return new AlignmentPattern(centerJ, centerI, estimatedModuleSize);
}
}
// Hadn't found this before; save it
var point = new AlignmentPattern(centerJ, centerI, estimatedModuleSize);
this.possibleCenters.push(point);
if (this.resultPointCallback != null) {
this.resultPointCallback.foundPossibleResultPoint(point);
}
}
return null;
};
AlignmentPatternFinder.prototype.find = function() {
var image = this.image;
var startX = this.startX;
var height = this.height;
var maxJ = startX + this.width;
var middleI = this.startY + (height >> 1);
// 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
var stateCount = [0, 0, 0];
for (var iGen = 0; iGen < height; iGen++) {
// Search from middle outwards
var i = middleI + ((iGen & 0x01) == 0 ? ((iGen + 1) >> 1) : -((iGen + 1) >> 1));
stateCount[0] = 0;
stateCount[1] = 0;
stateCount[2] = 0;
var 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 && !image.data[j + image.width * i]) {
j++;
}
var currentState = 0;
while (j < maxJ) {
if (image.data[j + i * image.width]) {
// Black pixel
if (currentState == 1) {
// Counting black pixels
stateCount[currentState]++;
} else {
// Counting white pixels
if (currentState == 2) {
// A winner?
if (this.foundPatternCross(stateCount)) {
// Yes
var 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)) {
var 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 (!(this.possibleCenters.length == 0)) {
return this.possibleCenters[0];
}
throw "Couldn't find enough alignment patterns";
};
node_modules/qrcode-reader/src/bitmat.js
Generated Vendored
+94
View File
@@ -0,0 +1,94 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
import {URShift} from './qrcode';
export default function BitMatrix(width, height) {
if (!height)
height = width;
if (width < 1 || height < 1) {
throw "Both dimensions must be greater than 0";
}
this.width = width;
this.height = height;
var rowSize = width >> 5;
if ((width & 0x1f) != 0) {
rowSize++;
}
this.rowSize = rowSize;
this.bits = new Array(rowSize * height);
for (var i = 0; i < this.bits.length; i++)
this.bits[i] = 0;
}
Object.defineProperty(BitMatrix.prototype, "Dimension", {
get: function() {
if (this.width != this.height) {
throw "Can't call getDimension() on a non-square matrix";
}
return this.width;
}
});
BitMatrix.prototype.get_Renamed = function(x, y) {
var offset = y * this.rowSize + (x >> 5);
return ((URShift(this.bits[offset], (x & 0x1f))) & 1) != 0;
};
BitMatrix.prototype.set_Renamed = function(x, y) {
var offset = y * this.rowSize + (x >> 5);
this.bits[offset] |= 1 << (x & 0x1f);
};
BitMatrix.prototype.flip = function(x, y) {
var offset = y * this.rowSize + (x >> 5);
this.bits[offset] ^= 1 << (x & 0x1f);
};
BitMatrix.prototype.clear = function() {
var max = this.bits.length;
for (var i = 0; i < max; i++) {
this.bits[i] = 0;
}
};
BitMatrix.prototype.setRegion = function(left, top, width, height) {
if (top < 0 || left < 0) {
throw "Left and top must be nonnegative";
}
if (height < 1 || width < 1) {
throw "Height and width must be at least 1";
}
var right = left + width;
var bottom = top + height;
if (bottom > this.height || right > this.width) {
throw "The region must fit inside the matrix";
}
for (var y = top; y < bottom; y++) {
var offset = y * this.rowSize;
for (var x = left; x < right; x++) {
this.bits[offset + (x >> 5)] |= 1 << (x & 0x1f);
}
}
};
node_modules/qrcode-reader/src/bmparser.js
Generated Vendored
+177
View File
@@ -0,0 +1,177 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
import FormatInformation from './formatinf';
import Version from './version';
import DataMask from './datamask';
export default function BitMatrixParser(bitMatrix) {
var dimension = bitMatrix.Dimension;
if (dimension < 21 || (dimension & 0x03) != 1) {
throw "Error BitMatrixParser";
}
this.bitMatrix = bitMatrix;
this.parsedVersion = null;
this.parsedFormatInfo = null;
}
BitMatrixParser.prototype.copyBit = function(i, j, versionBits) {
return this.bitMatrix.get_Renamed(i, j) ? (versionBits << 1) | 0x1 : versionBits << 1;
};
BitMatrixParser.prototype.readFormatInformation = function() {
if (this.parsedFormatInfo != null) {
return this.parsedFormatInfo;
}
// Read top-left format info bits
var formatInfoBits = 0;
for (var i = 0; i < 6; i++) {
formatInfoBits = this.copyBit(i, 8, formatInfoBits);
}
// .. and skip a bit in the timing pattern ...
formatInfoBits = this.copyBit(7, 8, formatInfoBits);
formatInfoBits = this.copyBit(8, 8, formatInfoBits);
formatInfoBits = this.copyBit(8, 7, formatInfoBits);
// .. and skip a bit in the timing pattern ...
for (var j = 5; j >= 0; j--) {
formatInfoBits = this.copyBit(8, j, formatInfoBits);
}
this.parsedFormatInfo = FormatInformation.decodeFormatInformation(formatInfoBits);
if (this.parsedFormatInfo != null) {
return this.parsedFormatInfo;
}
// Hmm, failed. Try the top-right/bottom-left pattern
var dimension = this.bitMatrix.Dimension;
formatInfoBits = 0;
var iMin = dimension - 8;
for (var i = dimension - 1; i >= iMin; i--) {
formatInfoBits = this.copyBit(i, 8, formatInfoBits);
}
for (var j = dimension - 7; j < dimension; j++) {
formatInfoBits = this.copyBit(8, j, formatInfoBits);
}
this.parsedFormatInfo = FormatInformation.decodeFormatInformation(formatInfoBits);
if (this.parsedFormatInfo != null) {
return this.parsedFormatInfo;
}
throw "Error readFormatInformation";
};
BitMatrixParser.prototype.readVersion = function() {
if (this.parsedVersion != null) {
return this.parsedVersion;
}
var dimension = this.bitMatrix.Dimension;
var provisionalVersion = (dimension - 17) >> 2;
if (provisionalVersion <= 6) {
return Version.getVersionForNumber(provisionalVersion);
}
// Read top-right version info: 3 wide by 6 tall
var versionBits = 0;
var ijMin = dimension - 11;
for (var j = 5; j >= 0; j--) {
for (var i = dimension - 9; i >= ijMin; i--) {
versionBits = this.copyBit(i, j, versionBits);
}
}
this.parsedVersion = Version.decodeVersionInformation(versionBits);
if (this.parsedVersion != null && this.parsedVersion.DimensionForVersion == dimension) {
return this.parsedVersion;
}
// Hmm, failed. Try bottom left: 6 wide by 3 tall
versionBits = 0;
for (var i = 5; i >= 0; i--) {
for (var j = dimension - 9; j >= ijMin; j--) {
versionBits = this.copyBit(i, j, versionBits);
}
}
this.parsedVersion = Version.decodeVersionInformation(versionBits);
if (this.parsedVersion != null && this.parsedVersion.DimensionForVersion == dimension) {
return this.parsedVersion;
}
throw "Error readVersion";
};
BitMatrixParser.prototype.readCodewords = function() {
var formatInfo = this.readFormatInformation();
var 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.
var dataMask = DataMask.forReference(formatInfo.dataMask);
var dimension = this.bitMatrix.Dimension;
dataMask.unmaskBitMatrix(this.bitMatrix, dimension);
var functionPattern = version.buildFunctionPattern();
var readingUp = true;
var result = new Array(version.totalCodewords);
var resultOffset = 0;
var currentByte = 0;
var bitsRead = 0;
// Read columns in pairs, from right to left
for (var 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 (var count = 0; count < dimension; count++) {
var i = readingUp ? dimension - 1 - count : count;
for (var col = 0; col < 2; col++) {
// Ignore bits covered by the function pattern
if (!functionPattern.get_Renamed(j - col, i)) {
// Read a bit
bitsRead++;
currentByte <<= 1;
if (this.bitMatrix.get_Renamed(j - col, i)) {
currentByte |= 1;
}
// If we've made a whole byte, save it off
if (bitsRead == 8) {
result[resultOffset++] = currentByte;
bitsRead = 0;
currentByte = 0;
}
}
}
}
readingUp ^= true; // readingUp = !readingUp; // switch directions
}
if (resultOffset != version.totalCodewords) {
throw "Error readCodewords";
}
return result;
};
node_modules/qrcode-reader/src/datablock.js
Generated Vendored
+95
View File
@@ -0,0 +1,95 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
export default function DataBlock(numDataCodewords, codewords) {
this.numDataCodewords = numDataCodewords;
this.codewords = codewords;
}
DataBlock.getDataBlocks = function(rawCodewords, version, ecLevel) {
if (rawCodewords.length != version.totalCodewords) {
throw "ArgumentException";
}
// Figure out the number and size of data blocks used by this version and
// error correction level
var ecBlocks = version.getECBlocksForLevel(ecLevel);
// First count the total number of data blocks
var totalBlocks = 0;
var ecBlockArray = ecBlocks.getECBlocks();
for (var i = 0; i < ecBlockArray.length; i++) {
totalBlocks += ecBlockArray[i].count;
}
// Now establish DataBlocks of the appropriate size and number of data codewords
var result = new Array(totalBlocks);
var numResultBlocks = 0;
for (var j = 0; j < ecBlockArray.length; j++) {
var ecBlock = ecBlockArray[j];
for (var i = 0; i < ecBlock.count; i++) {
var numDataCodewords = ecBlock.dataCodewords;
var numBlockCodewords = ecBlocks.ecCodewordsPerBlock + numDataCodewords;
result[numResultBlocks++] = new DataBlock(numDataCodewords, new Array(numBlockCodewords));
}
}
// 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.
var shorterBlocksTotalCodewords = result[0].codewords.length;
var longerBlocksStartAt = result.length - 1;
while (longerBlocksStartAt >= 0) {
var numCodewords = result[longerBlocksStartAt].codewords.length;
if (numCodewords == shorterBlocksTotalCodewords) {
break;
}
longerBlocksStartAt--;
}
longerBlocksStartAt++;
var shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks.ecCodewordsPerBlock;
// The last elements of result may be 1 element longer;
// first fill out as many elements as all of them have
var rawCodewordsOffset = 0;
for (var i = 0; i < shorterBlocksNumDataCodewords; i++) {
for (var j = 0; j < numResultBlocks; j++) {
result[j].codewords[i] = rawCodewords[rawCodewordsOffset++];
}
}
// Fill out the last data block in the longer ones
for (var j = longerBlocksStartAt; j < numResultBlocks; j++) {
result[j].codewords[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++];
}
// Now add in error correction blocks
var max = result[0].codewords.length;
for (var i = shorterBlocksNumDataCodewords; i < max; i++) {
for (var j = 0; j < numResultBlocks; j++) {
var iOffset = j < longerBlocksStartAt ? i : i + 1;
result[j].codewords[iOffset] = rawCodewords[rawCodewordsOffset++];
}
}
return result;
};
node_modules/qrcode-reader/src/databr.js
Generated Vendored
+273
View File
@@ -0,0 +1,273 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
import {qrcode} from './qrcode';
export default function QRCodeDataBlockReader(blocks, version, numErrorCorrectionCode) {
this.blockPointer = 0;
this.bitPointer = 7;
this.dataLength = 0;
this.blocks = blocks;
this.numErrorCorrectionCode = numErrorCorrectionCode;
if (version <= 9)
this.dataLengthMode = 0;
else if (version >= 10 && version <= 26)
this.dataLengthMode = 1;
else if (version >= 27 && version <= 40)
this.dataLengthMode = 2;
}
QRCodeDataBlockReader.prototype.getNextBits = function(numBits) {
var bits = 0;
if (numBits < this.bitPointer + 1) {
// next word fits into current data block
var mask = 0;
for (var i = 0; i < numBits; i++) {
mask += (1 << i);
}
mask <<= (this.bitPointer - numBits + 1);
bits = (this.blocks[this.blockPointer] & mask) >> (this.bitPointer - numBits + 1);
this.bitPointer -= numBits;
return bits;
} else if (numBits < this.bitPointer + 1 + 8) {
// next word crosses 2 data blocks
var mask1 = 0;
for (var i = 0; i < this.bitPointer + 1; i++) {
mask1 += (1 << i);
}
bits = (this.blocks[this.blockPointer] & mask1) << (numBits - (this.bitPointer + 1));
this.blockPointer++;
bits += ((this.blocks[this.blockPointer]) >> (8 - (numBits - (this.bitPointer + 1))));
this.bitPointer = this.bitPointer - numBits % 8;
if (this.bitPointer < 0) {
this.bitPointer = 8 + this.bitPointer;
}
return bits;
} else if (numBits < this.bitPointer + 1 + 16) {
// next word crosses 3 data blocks
var mask1 = 0; // mask of first block
var mask3 = 0; // mask of 3rd block
//bitPointer + 1 : number of bits of the 1st block
//8 : number of the 2nd block (note that use already 8bits because next word uses 3 data blocks)
//numBits - (bitPointer + 1 + 8) : number of bits of the 3rd block
for (var i = 0; i < this.bitPointer + 1; i++) {
mask1 += (1 << i);
}
var bitsFirstBlock = (this.blocks[this.blockPointer] & mask1) << (numBits - (this.bitPointer + 1));
this.blockPointer++;
var bitsSecondBlock = this.blocks[this.blockPointer] << (numBits - (this.bitPointer + 1 + 8));
this.blockPointer++;
for (var i = 0; i < numBits - (this.bitPointer + 1 + 8); i++) {
mask3 += (1 << i);
}
mask3 <<= 8 - (numBits - (this.bitPointer + 1 + 8));
var bitsThirdBlock = (this.blocks[this.blockPointer] & mask3) >> (8 - (numBits - (this.bitPointer + 1 + 8)));
bits = bitsFirstBlock + bitsSecondBlock + bitsThirdBlock;
this.bitPointer = this.bitPointer - (numBits - 8) % 8;
if (this.bitPointer < 0) {
this.bitPointer = 8 + this.bitPointer;
}
return bits;
} else {
return 0;
}
};
QRCodeDataBlockReader.prototype.NextMode = function() {
if ((this.blockPointer > this.blocks.length - this.numErrorCorrectionCode - 2))
return 0;
else
return this.getNextBits(4);
};
QRCodeDataBlockReader.prototype.getDataLength = function(modeIndicator) {
var index = 0;
while (true) {
if ((modeIndicator >> index) == 1)
break;
index++;
}
return this.getNextBits(qrcode.sizeOfDataLengthInfo[this.dataLengthMode][index]);
};
QRCodeDataBlockReader.prototype.getRomanAndFigureString = function(dataLength) {
var length = dataLength;
var intData = 0;
var strData = "";
var tableRomanAndFigure = ['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', ' ', '$', '%', '*', '+', '-', '.', '/', ':'];
do {
if (length > 1) {
intData = this.getNextBits(11);
var firstLetter = Math.floor(intData / 45);
var secondLetter = intData % 45;
strData += tableRomanAndFigure[firstLetter];
strData += tableRomanAndFigure[secondLetter];
length -= 2;
} else if (length == 1) {
intData = this.getNextBits(6);
strData += tableRomanAndFigure[intData];
length -= 1;
}
}
while (length > 0);
return strData;
};
QRCodeDataBlockReader.prototype.getFigureString = function(dataLength) {
var length = dataLength;
var intData = 0;
var strData = "";
do {
if (length >= 3) {
intData = this.getNextBits(10);
if (intData < 100)
strData += "0";
if (intData < 10)
strData += "0";
length -= 3;
} else if (length == 2) {
intData = this.getNextBits(7);
if (intData < 10)
strData += "0";
length -= 2;
} else if (length == 1) {
intData = this.getNextBits(4);
length -= 1;
}
strData += intData;
}
while (length > 0);
return strData;
};
QRCodeDataBlockReader.prototype.get8bitByteArray = function(dataLength) {
var length = dataLength;
var intData = 0;
var output = [];
do {
intData = this.getNextBits(8);
output.push(intData);
length--;
}
while (length > 0);
return output;
};
QRCodeDataBlockReader.prototype.getKanjiString = function(dataLength) {
var length = dataLength;
var intData = 0;
var unicodeString = "";
do {
intData = this.getNextBits(13);
var lowerByte = intData % 0xC0;
var higherByte = intData / 0xC0;
var tempWord = (higherByte << 8) + lowerByte;
var shiftjisWord = 0;
if (tempWord + 0x8140 <= 0x9FFC) {
// between 8140 - 9FFC on Shift_JIS character set
shiftjisWord = tempWord + 0x8140;
} else {
// between E040 - EBBF on Shift_JIS character set
shiftjisWord = tempWord + 0xC140;
}
unicodeString += String.fromCharCode(shiftjisWord);
length--;
}
while (length > 0);
return unicodeString;
};
Object.defineProperty(QRCodeDataBlockReader.prototype, "DataByte", {
get: function() {
var output = [];
var MODE_NUMBER = 1;
var MODE_ROMAN_AND_NUMBER = 2;
var MODE_8BIT_BYTE = 4;
var MODE_KANJI = 8;
do {
var mode = this.NextMode();
if (mode == 0) {
if (output.length > 0)
break;
else
throw "Empty data block";
}
//if (mode != 1 && mode != 2 && mode != 4 && mode != 8)
//}
if (mode != MODE_NUMBER && mode != MODE_ROMAN_AND_NUMBER && mode != MODE_8BIT_BYTE && mode != MODE_KANJI && mode != 7) {
/* canvas.println("Invalid mode: " + mode);
mode = guessMode(mode);
canvas.println("Guessed mode: " + mode); */
throw "Invalid mode: " + mode + " in (block:" + this.blockPointer + " bit:" + this.bitPointer + ")";
}
var dataLength = this.getDataLength(mode);
if (dataLength < 1)
throw "Invalid data length: " + dataLength;
switch (mode) {
case MODE_NUMBER:
var temp_str = this.getFigureString(dataLength);
var ta = new Array(temp_str.length);
for (var j = 0; j < temp_str.length; j++)
ta[j] = temp_str.charCodeAt(j);
output.push(ta);
break;
case MODE_ROMAN_AND_NUMBER:
var temp_str = this.getRomanAndFigureString(dataLength);
var ta = new Array(temp_str.length);
for (var j = 0; j < temp_str.length; j++)
ta[j] = temp_str.charCodeAt(j);
output.push(ta);
break;
case MODE_8BIT_BYTE:
var temp_sbyteArray3 = this.get8bitByteArray(dataLength);
output.push(temp_sbyteArray3);
break;
case MODE_KANJI:
var temp_str = this.getKanjiString(dataLength);
output.push(temp_str);
break;
}
//
}
while (true);
return output;
}
});
node_modules/qrcode-reader/src/datamask.js
Generated Vendored
+159
View File
@@ -0,0 +1,159 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
import {URShift} from './qrcode';
var DataMask = {};
DataMask.forReference = function(reference) {
if (reference < 0 || reference > 7) {
throw "System.ArgumentException";
}
return DataMask.DATA_MASKS[reference];
};
function DataMask000() {
this.unmaskBitMatrix = function(bits, dimension) {
for (var i = 0; i < dimension; i++) {
for (var j = 0; j < dimension; j++) {
if (this.isMasked(i, j)) {
bits.flip(j, i);
}
}
}
};
this.isMasked = function(i, j) {
return ((i + j) & 0x01) == 0;
};
}
function DataMask001() {
this.unmaskBitMatrix = function(bits, dimension) {
for (var i = 0; i < dimension; i++) {
for (var j = 0; j < dimension; j++) {
if (this.isMasked(i, j)) {
bits.flip(j, i);
}
}
}
};
this.isMasked = function(i, j) {
return (i & 0x01) == 0;
};
}
function DataMask010() {
this.unmaskBitMatrix = function(bits, dimension) {
for (var i = 0; i < dimension; i++) {
for (var j = 0; j < dimension; j++) {
if (this.isMasked(i, j)) {
bits.flip(j, i);
}
}
}
};
this.isMasked = function(i, j) {
return j % 3 == 0;
};
}
function DataMask011() {
this.unmaskBitMatrix = function(bits, dimension) {
for (var i = 0; i < dimension; i++) {
for (var j = 0; j < dimension; j++) {
if (this.isMasked(i, j)) {
bits.flip(j, i);
}
}
}
};
this.isMasked = function(i, j) {
return (i + j) % 3 == 0;
};
}
function DataMask100() {
this.unmaskBitMatrix = function(bits, dimension) {
for (var i = 0; i < dimension; i++) {
for (var j = 0; j < dimension; j++) {
if (this.isMasked(i, j)) {
bits.flip(j, i);
}
}
}
};
this.isMasked = function(i, j) {
return (((URShift(i, 1)) + (j / 3)) & 0x01) == 0;
};
}
function DataMask101() {
this.unmaskBitMatrix = function(bits, dimension) {
for (var i = 0; i < dimension; i++) {
for (var j = 0; j < dimension; j++) {
if (this.isMasked(i, j)) {
bits.flip(j, i);
}
}
}
};
this.isMasked = function(i, j) {
var temp = i * j;
return (temp & 0x01) + (temp % 3) == 0;
};
}
function DataMask110() {
this.unmaskBitMatrix = function(bits, dimension) {
for (var i = 0; i < dimension; i++) {
for (var j = 0; j < dimension; j++) {
if (this.isMasked(i, j)) {
bits.flip(j, i);
}
}
}
};
this.isMasked = function(i, j) {
var temp = i * j;
return (((temp & 0x01) + (temp % 3)) & 0x01) == 0;
};
}
function DataMask111() {
this.unmaskBitMatrix = function(bits, dimension) {
for (var i = 0; i < dimension; i++) {
for (var j = 0; j < dimension; j++) {
if (this.isMasked(i, j)) {
bits.flip(j, i);
}
}
}
};
this.isMasked = function(i, j) {
return ((((i + j) & 0x01) + ((i * j) % 3)) & 0x01) == 0;
};
}
DataMask.DATA_MASKS = [new DataMask000(), new DataMask001(), new DataMask010(), new DataMask011(), new DataMask100(), new DataMask101(), new DataMask110(), new DataMask111()];
export default DataMask;
node_modules/qrcode-reader/src/decoder.js
Generated Vendored
+89
View File
@@ -0,0 +1,89 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
import ReedSolomonDecoder from './rsdecoder';
import GF256 from './gf256';
import BitMatrixParser from './bmparser';
import DataBlock from './datablock';
import QRCodeDataBlockReader from './databr';
var Decoder = {};
Decoder.rsDecoder = new ReedSolomonDecoder(GF256.QR_CODE_FIELD);
Decoder.correctErrors = function(codewordBytes, numDataCodewords) {
var numCodewords = codewordBytes.length;
// First read into an array of ints
var codewordsInts = new Array(numCodewords);
for (var i = 0; i < numCodewords; i++) {
codewordsInts[i] = codewordBytes[i] & 0xFF;
}
var numECCodewords = codewordBytes.length - numDataCodewords;
try {
Decoder.rsDecoder.decode(codewordsInts, numECCodewords);
} catch (rse) {
throw rse;
}
// 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 (var i = 0; i < numDataCodewords; i++) {
codewordBytes[i] = codewordsInts[i];
}
};
Decoder.decode = function(bits) {
var parser = new BitMatrixParser(bits);
var version = parser.readVersion();
var ecLevel = parser.readFormatInformation().errorCorrectionLevel;
// Read codewords
var codewords = parser.readCodewords();
// Separate into data blocks
var dataBlocks = DataBlock.getDataBlocks(codewords, version, ecLevel);
// Count total number of data bytes
var totalBytes = 0;
for (var i = 0; i < dataBlocks.length; i++) {
totalBytes += dataBlocks[i].numDataCodewords;
}
var resultBytes = new Array(totalBytes);
var resultOffset = 0;
// Error-correct and copy data blocks together into a stream of bytes
for (var j = 0; j < dataBlocks.length; j++) {
var dataBlock = dataBlocks[j];
var codewordBytes = dataBlock.codewords;
var numDataCodewords = dataBlock.numDataCodewords;
Decoder.correctErrors(codewordBytes, numDataCodewords);
for (var i = 0; i < numDataCodewords; i++) {
resultBytes[resultOffset++] = codewordBytes[i];
}
}
// Decode the contents of that stream of bytes
var reader = new QRCodeDataBlockReader(resultBytes, version.versionNumber, ecLevel.bits);
return reader;
};
export default Decoder;
node_modules/qrcode-reader/src/detector.js
Generated Vendored
+356
View File
@@ -0,0 +1,356 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
import Version from './version';
import {AlignmentPatternFinder} from './alignpat';
import GridSampler from './grid';
import {FinderPatternFinder} from './findpat';
function PerspectiveTransform(a11, a21, a31, a12, a22, a32, a13, a23, a33) {
this.a11 = a11;
this.a12 = a12;
this.a13 = a13;
this.a21 = a21;
this.a22 = a22;
this.a23 = a23;
this.a31 = a31;
this.a32 = a32;
this.a33 = a33;
}
PerspectiveTransform.prototype.transformPoints1 = function(points) {
var max = points.length;
var a11 = this.a11;
var a12 = this.a12;
var a13 = this.a13;
var a21 = this.a21;
var a22 = this.a22;
var a23 = this.a23;
var a31 = this.a31;
var a32 = this.a32;
var a33 = this.a33;
for (var i = 0; i < max; i += 2) {
var x = points[i];
var y = points[i + 1];
var denominator = a13 * x + a23 * y + a33;
points[i] = (a11 * x + a21 * y + a31) / denominator;
points[i + 1] = (a12 * x + a22 * y + a32) / denominator;
}
};
PerspectiveTransform.prototype.transformPoints2 = function(xValues, yValues) {
var n = xValues.length;
for (var i = 0; i < n; i++) {
var x = xValues[i];
var y = yValues[i];
var denominator = this.a13 * x + this.a23 * y + this.a33;
xValues[i] = (this.a11 * x + this.a21 * y + this.a31) / denominator;
yValues[i] = (this.a12 * x + this.a22 * y + this.a32) / denominator;
}
};
PerspectiveTransform.prototype.buildAdjoint = function() {
// Adjoint is the transpose of the cofactor matrix:
return new PerspectiveTransform(this.a22 * this.a33 - this.a23 * this.a32, this.a23 * this.a31 - this.a21 * this.a33, this.a21 * this.a32 - this.a22 * this.a31, this.a13 * this.a32 - this.a12 * this.a33, this.a11 * this.a33 - this.a13 * this.a31, this.a12 * this.a31 - this.a11 * this.a32, this.a12 * this.a23 - this.a13 * this.a22, this.a13 * this.a21 - this.a11 * this.a23, this.a11 * this.a22 - this.a12 * this.a21);
};
PerspectiveTransform.prototype.times = function(other) {
return new PerspectiveTransform(this.a11 * other.a11 + this.a21 * other.a12 + this.a31 * other.a13, this.a11 * other.a21 + this.a21 * other.a22 + this.a31 * other.a23, this.a11 * other.a31 + this.a21 * other.a32 + this.a31 * other.a33, this.a12 * other.a11 + this.a22 * other.a12 + this.a32 * other.a13, this.a12 * other.a21 + this.a22 * other.a22 + this.a32 * other.a23, this.a12 * other.a31 + this.a22 * other.a32 + this.a32 * other.a33, this.a13 * other.a11 + this.a23 * other.a12 + this.a33 * other.a13, this.a13 * other.a21 + this.a23 * other.a22 + this.a33 * other.a23, this.a13 * other.a31 + this.a23 * other.a32 + this.a33 * other.a33);
};
PerspectiveTransform.quadrilateralToQuadrilateral = function(x0, y0, x1, y1, x2, y2, x3, y3, x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p) {
var qToS = this.quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3);
var sToQ = this.squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p);
return sToQ.times(qToS);
};
PerspectiveTransform.squareToQuadrilateral = function(x0, y0, x1, y1, x2, y2, x3, y3) {
var dy2 = y3 - y2;
var dy3 = y0 - y1 + y2 - y3;
if (dy2 == 0.0 && dy3 == 0.0) {
return new PerspectiveTransform(x1 - x0, x2 - x1, x0, y1 - y0, y2 - y1, y0, 0.0, 0.0, 1.0);
} else {
var dx1 = x1 - x2;
var dx2 = x3 - x2;
var dx3 = x0 - x1 + x2 - x3;
var dy1 = y1 - y2;
var denominator = dx1 * dy2 - dx2 * dy1;
var a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
var a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
return new PerspectiveTransform(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0, y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0, a13, a23, 1.0);
}
};
PerspectiveTransform.quadrilateralToSquare = function(x0, y0, x1, y1, x2, y2, x3, y3) {
// Here, the adjoint serves as the inverse:
return this.squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3).buildAdjoint();
};
function DetectorResult(bits, points) {
this.bits = bits;
this.points = points;
}
export default function Detector(image) {
this.image = image;
this.resultPointCallback = null;
}
Detector.prototype.sizeOfBlackWhiteBlackRun = function(fromX, fromY, toX, toY) {
// Mild variant of Bresenham's algorithm;
// see http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
var steep = Math.abs(toY - fromY) > Math.abs(toX - fromX);
if (steep) {
var temp = fromX;
fromX = fromY;
fromY = temp;
temp = toX;
toX = toY;
toY = temp;
}
var dx = Math.abs(toX - fromX);
var dy = Math.abs(toY - fromY);
var error = -dx >> 1;
var ystep = fromY < toY ? 1 : -1;
var xstep = fromX < toX ? 1 : -1;
var state = 0; // In black pixels, looking for white, first or second time
for (var x = fromX, y = fromY; x != toX; x += xstep) {
var realX = steep ? y : x;
var realY = steep ? x : y;
if (state == 1) {
// In white pixels, looking for black
if (this.image.data[realX + realY * this.image.width]) {
state++;
}
} else {
if (!this.image.data[realX + realY * this.image.width]) {
state++;
}
}
if (state == 3) {
// Found black, white, black, and stumbled back onto white; done
var diffX = x - fromX;
var diffY = y - fromY;
return Math.sqrt((diffX * diffX + diffY * diffY));
}
error += dy;
if (error > 0) {
if (y == toY) {
break;
}
y += ystep;
error -= dx;
}
}
var diffX2 = toX - fromX;
var diffY2 = toY - fromY;
return Math.sqrt((diffX2 * diffX2 + diffY2 * diffY2));
};
Detector.prototype.sizeOfBlackWhiteBlackRunBothWays = function(fromX, fromY, toX, toY) {
var result = this.sizeOfBlackWhiteBlackRun(fromX, fromY, toX, toY);
// Now count other way -- don't run off image though of course
var scale = 1.0;
var otherToX = fromX - (toX - fromX);
if (otherToX < 0) {
scale = fromX / (fromX - otherToX);
otherToX = 0;
} else if (otherToX >= this.image.width) {
scale = (this.image.width - 1 - fromX) / (otherToX - fromX);
otherToX = this.image.width - 1;
}
var otherToY = Math.floor(fromY - (toY - fromY) * scale);
scale = 1.0;
if (otherToY < 0) {
scale = fromY / (fromY - otherToY);
otherToY = 0;
} else if (otherToY >= this.image.height) {
scale = (this.image.height - 1 - fromY) / (otherToY - fromY);
otherToY = this.image.height - 1;
}
otherToX = Math.floor(fromX + (otherToX - fromX) * scale);
result += this.sizeOfBlackWhiteBlackRun(fromX, fromY, otherToX, otherToY);
return result - 1.0; // -1 because we counted the middle pixel twice
};
Detector.prototype.calculateModuleSizeOneWay = function(pattern, otherPattern) {
var moduleSizeEst1 = this.sizeOfBlackWhiteBlackRunBothWays(Math.floor(pattern.X), Math.floor(pattern.Y), Math.floor(otherPattern.X), Math.floor(otherPattern.Y));
var moduleSizeEst2 = this.sizeOfBlackWhiteBlackRunBothWays(Math.floor(otherPattern.X), Math.floor(otherPattern.Y), Math.floor(pattern.X), Math.floor(pattern.Y));
if (isNaN(moduleSizeEst1)) {
return moduleSizeEst2 / 7.0;
}
if (isNaN(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;
};
Detector.prototype.calculateModuleSize = function(topLeft, topRight, bottomLeft) {
// Take the average
return (this.calculateModuleSizeOneWay(topLeft, topRight) + this.calculateModuleSizeOneWay(topLeft, bottomLeft)) / 2.0;
};
Detector.prototype.distance = function(pattern1, pattern2) {
var xDiff = pattern1.X - pattern2.X;
var yDiff = pattern1.Y - pattern2.Y;
return Math.sqrt((xDiff * xDiff + yDiff * yDiff));
};
Detector.prototype.computeDimension = function(topLeft, topRight, bottomLeft, moduleSize) {
var tltrCentersDimension = Math.round(this.distance(topLeft, topRight) / moduleSize);
var tlblCentersDimension = Math.round(this.distance(topLeft, bottomLeft) / moduleSize);
var dimension = ((tltrCentersDimension + tlblCentersDimension) >> 1) + 7;
switch (dimension & 0x03) {
// mod 4
case 0:
dimension++;
break;
// 1? do nothing
case 2:
dimension--;
break;
case 3:
throw "Error";
}
return dimension;
};
Detector.prototype.findAlignmentInRegion = function(overallEstModuleSize, estAlignmentX, estAlignmentY, allowanceFactor) {
// Look for an alignment pattern (3 modules in size) around where it
// should be
var allowance = Math.floor(allowanceFactor * overallEstModuleSize);
var alignmentAreaLeftX = Math.max(0, estAlignmentX - allowance);
var alignmentAreaRightX = Math.min(this.image.width - 1, estAlignmentX + allowance);
if (alignmentAreaRightX - alignmentAreaLeftX < overallEstModuleSize * 3) {
throw "Error";
}
var alignmentAreaTopY = Math.max(0, estAlignmentY - allowance);
var alignmentAreaBottomY = Math.min(this.image.height - 1, estAlignmentY + allowance);
var alignmentFinder = new AlignmentPatternFinder(this.image, alignmentAreaLeftX, alignmentAreaTopY, alignmentAreaRightX - alignmentAreaLeftX, alignmentAreaBottomY - alignmentAreaTopY, overallEstModuleSize, this.resultPointCallback);
return alignmentFinder.find();
};
Detector.prototype.createTransform = function(topLeft, topRight, bottomLeft, alignmentPattern, dimension) {
var dimMinusThree = dimension - 3.5;
var bottomRightX;
var bottomRightY;
var sourceBottomRightX;
var sourceBottomRightY;
if (alignmentPattern != null) {
bottomRightX = alignmentPattern.X;
bottomRightY = alignmentPattern.Y;
sourceBottomRightX = sourceBottomRightY = dimMinusThree - 3.0;
} else {
// Don't have an alignment pattern, just make up the bottom-right point
bottomRightX = (topRight.X - topLeft.X) + bottomLeft.X;
bottomRightY = (topRight.Y - topLeft.Y) + bottomLeft.Y;
sourceBottomRightX = sourceBottomRightY = dimMinusThree;
}
var transform = PerspectiveTransform.quadrilateralToQuadrilateral(3.5, 3.5, dimMinusThree, 3.5, sourceBottomRightX, sourceBottomRightY, 3.5, dimMinusThree, topLeft.X, topLeft.Y, topRight.X, topRight.Y, bottomRightX, bottomRightY, bottomLeft.X, bottomLeft.Y);
return transform;
};
Detector.prototype.sampleGrid = function(image, transform, dimension) {
var sampler = GridSampler;
return sampler.sampleGrid3(image, dimension, transform);
};
Detector.prototype.processFinderPatternInfo = function(info) {
var topLeft = info.topLeft;
var topRight = info.topRight;
var bottomLeft = info.bottomLeft;
var moduleSize = this.calculateModuleSize(topLeft, topRight, bottomLeft);
if (moduleSize < 1.0) {
throw "Error";
}
var dimension = this.computeDimension(topLeft, topRight, bottomLeft, moduleSize);
var provisionalVersion = Version.getProvisionalVersionForDimension(dimension);
var modulesBetweenFPCenters = provisionalVersion.DimensionForVersion - 7;
var alignmentPattern = null;
// Anything above version 1 has an alignment pattern
if (provisionalVersion.alignmentPatternCenters.length > 0) {
// Guess where a "bottom right" finder pattern would have been
var bottomRightX = topRight.X - topLeft.X + bottomLeft.X;
var bottomRightY = topRight.Y - topLeft.Y + bottomLeft.Y;
// Estimate that alignment pattern is closer by 3 modules
// from "bottom right" to known top left location
var correctionToTopLeft = 1.0 - 3.0 / modulesBetweenFPCenters;
var estAlignmentX = Math.floor(topLeft.X + correctionToTopLeft * (bottomRightX - topLeft.X));
var estAlignmentY = Math.floor(topLeft.Y + correctionToTopLeft * (bottomRightY - topLeft.Y));
// Kind of arbitrary -- expand search radius before giving up
for (var i = 4; i <= 16; i <<= 1) {
//try
//{
alignmentPattern = this.findAlignmentInRegion(moduleSize, estAlignmentX, estAlignmentY, i);
break;
//}
//catch (re)
//{
// try next round
//}
}
// If we didn't find alignment pattern... well try anyway without it
}
var transform = this.createTransform(topLeft, topRight, bottomLeft, alignmentPattern, dimension);
var bits = this.sampleGrid(this.image, transform, dimension);
var points;
if (alignmentPattern == null) {
points = [bottomLeft, topLeft, topRight];
} else {
points = [bottomLeft, topLeft, topRight, alignmentPattern];
}
return new DetectorResult(bits, points);
};
Detector.prototype.detect = function() {
var info = new FinderPatternFinder().findFinderPattern(this.image);
return this.processFinderPatternInfo(info);
};
node_modules/qrcode-reader/src/errorlevel.js
Generated Vendored
+48
View File
@@ -0,0 +1,48 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
export default function ErrorCorrectionLevel(ordinal, bits, name) {
this.ordinal_Renamed_Field = ordinal;
this.bits = bits;
this.name = name;
}
ErrorCorrectionLevel.prototype.ordinal = function() {
return this.ordinal_Renamed_Field;
};
ErrorCorrectionLevel.forBits = function(bits) {
if (bits < 0 || bits >= FOR_BITS.length) {
throw "ArgumentException";
}
return FOR_BITS[bits];
};
var FOR_BITS = [
new ErrorCorrectionLevel(1, 0x00, "M"),
new ErrorCorrectionLevel(0, 0x01, "L"),
new ErrorCorrectionLevel(3, 0x02, "H"),
new ErrorCorrectionLevel(2, 0x03, "Q"),
];
node_modules/qrcode-reader/src/findpat.js
Generated Vendored
+532
View File
@@ -0,0 +1,532 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
var MIN_SKIP = 3;
var MAX_MODULES = 57;
var INTEGER_MATH_SHIFT = 8;
var CENTER_QUORUM = 2;
function orderBestPatterns(patterns) {
function distance(pattern1, pattern2) {
var xDiff = pattern1.X - pattern2.X;
var yDiff = pattern1.Y - pattern2.Y;
return Math.sqrt((xDiff * xDiff + yDiff * yDiff));
}
/// <summary> Returns the z component of the cross product between vectors BC and BA.</summary>
function crossProductZ(pointA, pointB, pointC) {
var bX = pointB.x;
var bY = pointB.y;
return ((pointC.x - bX) * (pointA.y - bY)) - ((pointC.y - bY) * (pointA.x - bX));
}
// Find distances between pattern centers
var zeroOneDistance = distance(patterns[0], patterns[1]);
var oneTwoDistance = distance(patterns[1], patterns[2]);
var zeroTwoDistance = distance(patterns[0], patterns[2]);
var pointA, pointB, pointC;
// Assume one closest to other two is B; A and C will just be guesses at first
if (oneTwoDistance >= zeroOneDistance && oneTwoDistance >= zeroTwoDistance) {
pointB = patterns[0];
pointA = patterns[1];
pointC = patterns[2];
} else if (zeroTwoDistance >= oneTwoDistance && zeroTwoDistance >= zeroOneDistance) {
pointB = patterns[1];
pointA = patterns[0];
pointC = patterns[2];
} else {
pointB = patterns[2];
pointA = patterns[0];
pointC = patterns[1];
}
// Use cross product to figure out whether A and C are correct or flipped.
// This asks whether BC x BA has a positive z component, which is the arrangement
// we want for A, B, C. If it's negative, then we've got it flipped around and
// should swap A and C.
if (crossProductZ(pointA, pointB, pointC) < 0.0) {
var temp = pointA;
pointA = pointC;
pointC = temp;
}
patterns[0] = pointA;
patterns[1] = pointB;
patterns[2] = pointC;
}
function FinderPattern(posX, posY, estimatedModuleSize) {
this.x = posX;
this.y = posY;
this.count = 1;
this.estimatedModuleSize = estimatedModuleSize;
}
Object.defineProperty(FinderPattern.prototype, "X", {
get: function() {
return this.x;
}
});
Object.defineProperty(FinderPattern.prototype, "Y", {
get: function() {
return this.y;
}
});
FinderPattern.prototype.incrementCount = function() {
this.count++;
};
FinderPattern.prototype.aboutEquals = function(moduleSize, i, j) {
if (Math.abs(i - this.y) <= moduleSize && Math.abs(j - this.x) <= moduleSize) {
var moduleSizeDiff = Math.abs(moduleSize - this.estimatedModuleSize);
return moduleSizeDiff <= 1.0 || moduleSizeDiff / this.estimatedModuleSize <= 1.0;
}
return false;
};
function FinderPatternInfo(patternCenters) {
this.bottomLeft = patternCenters[0];
this.topLeft = patternCenters[1];
this.topRight = patternCenters[2];
}
export function FinderPatternFinder() {
this.image = null;
this.possibleCenters = [];
this.hasSkipped = false;
this.crossCheckStateCount = [0, 0, 0, 0, 0];
this.resultPointCallback = null;
}
Object.defineProperty(FinderPatternFinder.prototype, "CrossCheckStateCount", {
get: function() {
this.crossCheckStateCount[0] = 0;
this.crossCheckStateCount[1] = 0;
this.crossCheckStateCount[2] = 0;
this.crossCheckStateCount[3] = 0;
this.crossCheckStateCount[4] = 0;
return this.crossCheckStateCount;
}
});
FinderPatternFinder.prototype.foundPatternCross = function(stateCount) {
var totalModuleSize = 0;
for (var i = 0; i < 5; i++) {
var count = stateCount[i];
if (count == 0) {
return false;
}
totalModuleSize += count;
}
if (totalModuleSize < 7) {
return false;
}
var moduleSize = Math.floor((totalModuleSize << INTEGER_MATH_SHIFT) / 7);
var maxVariance = Math.floor(moduleSize / 2);
// Allow less than 50% variance from 1-1-3-1-1 proportions
return Math.abs(moduleSize - (stateCount[0] << INTEGER_MATH_SHIFT)) < maxVariance && Math.abs(moduleSize - (stateCount[1] << INTEGER_MATH_SHIFT)) < maxVariance && Math.abs(3 * moduleSize - (stateCount[2] << INTEGER_MATH_SHIFT)) < 3 * maxVariance && Math.abs(moduleSize - (stateCount[3] << INTEGER_MATH_SHIFT)) < maxVariance && Math.abs(moduleSize - (stateCount[4] << INTEGER_MATH_SHIFT)) < maxVariance;
};
FinderPatternFinder.prototype.centerFromEnd = function(stateCount, end) {
return (end - stateCount[4] - stateCount[3]) - stateCount[2] / 2.0;
};
FinderPatternFinder.prototype.crossCheckVertical = function(startI, centerJ, maxCount, originalStateCountTotal) {
var image = this.image;
var maxI = image.height;
var stateCount = this.CrossCheckStateCount;
// Start counting up from center
var i = startI;
while (i >= 0 && image.data[centerJ + i * image.width]) {
stateCount[2]++;
i--;
}
if (i < 0) {
return NaN;
}
while (i >= 0 && !image.data[centerJ + i * image.width] && 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.data[centerJ + i * image.width] && 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.data[centerJ + i * image.width]) {
stateCount[2]++;
i++;
}
if (i == maxI) {
return NaN;
}
while (i < maxI && !image.data[centerJ + i * image.width] && stateCount[3] < maxCount) {
stateCount[3]++;
i++;
}
if (i == maxI || stateCount[3] >= maxCount) {
return NaN;
}
while (i < maxI && image.data[centerJ + i * image.width] && 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
var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {
return NaN;
}
return this.foundPatternCross(stateCount) ? this.centerFromEnd(stateCount, i) : NaN;
};
FinderPatternFinder.prototype.crossCheckHorizontal = function(startJ, centerI, maxCount, originalStateCountTotal) {
var image = this.image;
var maxJ = image.width;
var stateCount = this.CrossCheckStateCount;
var j = startJ;
while (j >= 0 && image.data[j + centerI * image.width]) {
stateCount[2]++;
j--;
}
if (j < 0) {
return NaN;
}
while (j >= 0 && !image.data[j + centerI * image.width] && stateCount[1] <= maxCount) {
stateCount[1]++;
j--;
}
if (j < 0 || stateCount[1] > maxCount) {
return NaN;
}
while (j >= 0 && image.data[j + centerI * image.width] && stateCount[0] <= maxCount) {
stateCount[0]++;
j--;
}
if (stateCount[0] > maxCount) {
return NaN;
}
j = startJ + 1;
while (j < maxJ && image.data[j + centerI * image.width]) {
stateCount[2]++;
j++;
}
if (j == maxJ) {
return NaN;
}
while (j < maxJ && !image.data[j + centerI * image.width] && stateCount[3] < maxCount) {
stateCount[3]++;
j++;
}
if (j == maxJ || stateCount[3] >= maxCount) {
return NaN;
}
while (j < maxJ && image.data[j + centerI * image.width] && 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
var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= originalStateCountTotal) {
return NaN;
}
return this.foundPatternCross(stateCount) ? this.centerFromEnd(stateCount, j) : NaN;
};
FinderPatternFinder.prototype.handlePossibleCenter = function(stateCount, i, j) {
var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
var centerJ = this.centerFromEnd(stateCount, j); //float
var centerI = this.crossCheckVertical(i, Math.floor(centerJ), stateCount[2], stateCountTotal); //float
if (!isNaN(centerI)) {
// Re-cross check
centerJ = this.crossCheckHorizontal(Math.floor(centerJ), Math.floor(centerI), stateCount[2], stateCountTotal);
if (!isNaN(centerJ)) {
var estimatedModuleSize = stateCountTotal / 7.0;
var found = false;
var max = this.possibleCenters.length;
for (var index = 0; index < max; index++) {
var center = this.possibleCenters[index];
// Look for about the same center and module size:
if (center.aboutEquals(estimatedModuleSize, centerI, centerJ)) {
center.incrementCount();
found = true;
break;
}
}
if (!found) {
var point = new FinderPattern(centerJ, centerI, estimatedModuleSize);
this.possibleCenters.push(point);
if (this.resultPointCallback != null) {
this.resultPointCallback.foundPossibleResultPoint(point);
}
}
return true;
}
}
return false;
};
FinderPatternFinder.prototype.selectBestPatterns = function() {
var startSize = this.possibleCenters.length;
if (startSize < 3) {
// Couldn't find enough finder patterns
throw "Couldn't find enough finder patterns:" + startSize + " patterns found";
}
// 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
var totalModuleSize = 0.0;
var square = 0.0;
for (var i = 0; i < startSize; i++) {
var centerValue = this.possibleCenters[i].estimatedModuleSize;
totalModuleSize += centerValue;
square += (centerValue * centerValue);
}
var average = totalModuleSize / startSize;
this.possibleCenters.sort(function(center1, center2) {
var dA = Math.abs(center2.estimatedModuleSize - average);
var dB = Math.abs(center1.estimatedModuleSize - average);
if (dA < dB) {
return (-1);
} else if (dA == dB) {
return 0;
} else {
return 1;
}
});
var stdDev = Math.sqrt(square / startSize - average * average);
var limit = Math.max(0.2 * average, stdDev);
for (var i = this.possibleCenters - 1; i >= 0; i--) {
var pattern = this.possibleCenters[i];
if (Math.abs(pattern.estimatedModuleSize - average) > limit) {
this.possibleCenters.splice(i, 1);
}
}
}
if (this.possibleCenters.length > 3) {
// Throw away all but those first size candidate points we found.
this.possibleCenters.sort(function(a, b) {
if (a.count > b.count) return -1;
if (a.count < b.count) return 1;
return 0;
});
}
return [this.possibleCenters[0], this.possibleCenters[1], this.possibleCenters[2]];
};
FinderPatternFinder.prototype.findRowSkip = function() {
var max = this.possibleCenters.length;
if (max <= 1) {
return 0;
}
var firstConfirmedCenter = null;
for (var i = 0; i < max; i++) {
var center = this.possibleCenters[i];
if (center.count >= 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 Math.floor((Math.abs(firstConfirmedCenter.X - center.X) - Math.abs(firstConfirmedCenter.Y - center.Y)) / 2);
}
}
}
return 0;
};
FinderPatternFinder.prototype.haveMultiplyConfirmedCenters = function() {
var confirmedCount = 0;
var totalModuleSize = 0.0;
var max = this.possibleCenters.length;
for (var i = 0; i < max; i++) {
var pattern = this.possibleCenters[i];
if (pattern.count >= CENTER_QUORUM) {
confirmedCount++;
totalModuleSize += pattern.estimatedModuleSize;
}
}
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.
var average = totalModuleSize / max;
var totalDeviation = 0.0;
for (var i = 0; i < max; i++) {
pattern = this.possibleCenters[i];
totalDeviation += Math.abs(pattern.estimatedModuleSize - average);
}
return totalDeviation <= 0.05 * totalModuleSize;
};
FinderPatternFinder.prototype.findFinderPattern = function(image) {
var tryHarder = false;
this.image = image;
var maxI = image.height;
var maxJ = image.width;
var iSkip = Math.floor((3 * maxI) / (4 * MAX_MODULES));
if (iSkip < MIN_SKIP || tryHarder) {
iSkip = MIN_SKIP;
}
var done = false;
var stateCount = new Array(5);
for (var 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;
var currentState = 0;
for (var j = 0; j < maxJ; j++) {
if (image.data[j + i * image.width]) {
// 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 (this.foundPatternCross(stateCount)) {
// Yes
var confirmed = this.handlePossibleCenter(stateCount, i, j);
if (confirmed) {
// Start examining every other line. Checking each line turned out to be too
// expensive and didn't improve performance.
iSkip = 2;
if (this.hasSkipped) {
done = this.haveMultiplyConfirmedCenters();
} else {
var 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 {
// Advance to next black pixel
do {
j++;
} while (j < maxJ && !image.data[j + i * image.width]);
j--; // back up to that last white pixel
}
// 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 (this.foundPatternCross(stateCount)) {
var confirmed = this.handlePossibleCenter(stateCount, i, maxJ);
if (confirmed) {
iSkip = stateCount[0];
if (this.hasSkipped) {
// Found a third one
done = this.haveMultiplyConfirmedCenters();
}
}
}
}
var patternInfo = this.selectBestPatterns();
orderBestPatterns(patternInfo);
return new FinderPatternInfo(patternInfo);
};
node_modules/qrcode-reader/src/formatinf.js
Generated Vendored
+121
View File
@@ -0,0 +1,121 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
import {URShift} from './qrcode';
import ErrorCorrectionLevel from './errorlevel';
var FORMAT_INFO_MASK_QR = 0x5412;
var 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],
];
var BITS_SET_IN_HALF_BYTE = [0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4];
export default function FormatInformation(formatInfo) {
this.errorCorrectionLevel = ErrorCorrectionLevel.forBits((formatInfo >> 3) & 0x03);
this.dataMask = (formatInfo & 0x07);
}
FormatInformation.prototype.GetHashCode = function() {
return (this.errorCorrectionLevel.ordinal() << 3) | this.dataMask;
};
FormatInformation.prototype.Equals = function(o) {
var other = o;
return this.errorCorrectionLevel == other.errorCorrectionLevel && this.dataMask == other.dataMask;
};
FormatInformation.numBitsDiffering = function(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 BITS_SET_IN_HALF_BYTE[a & 0x0F] + BITS_SET_IN_HALF_BYTE[(URShift(a, 4) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(URShift(a, 8) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(URShift(a, 12) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(URShift(a, 16) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(URShift(a, 20) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(URShift(a, 24) & 0x0F)] + BITS_SET_IN_HALF_BYTE[(URShift(a, 28) & 0x0F)];
};
FormatInformation.decodeFormatInformation = function(maskedFormatInfo) {
var formatInfo = FormatInformation.doDecodeFormatInformation(maskedFormatInfo);
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 FormatInformation.doDecodeFormatInformation(maskedFormatInfo ^ FORMAT_INFO_MASK_QR);
};
FormatInformation.doDecodeFormatInformation = function(maskedFormatInfo) {
// Find the int in FORMAT_INFO_DECODE_LOOKUP with fewest bits differing
var bestDifference = 0xffffffff;
var bestFormatInfo = 0;
for (var i = 0; i < FORMAT_INFO_DECODE_LOOKUP.length; i++) {
var decodeInfo = FORMAT_INFO_DECODE_LOOKUP[i];
var targetInfo = decodeInfo[0];
if (targetInfo == maskedFormatInfo) {
// Found an exact match
return new FormatInformation(decodeInfo[1]);
}
var bitsDifference = this.numBitsDiffering(maskedFormatInfo, 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;
};
node_modules/qrcode-reader/src/gf256.js
Generated Vendored
+109
View File
@@ -0,0 +1,109 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
import GF256Poly from './gf256poly';
export default function GF256(primitive) {
this.expTable = new Array(256);
this.logTable = new Array(256);
var x = 1;
for (var i = 0; i < 256; i++) {
this.expTable[i] = x;
x <<= 1; // x = x * 2; we're assuming the generator alpha is 2
if (x >= 0x100) {
x ^= primitive;
}
}
for (var i = 0; i < 255; i++) {
this.logTable[this.expTable[i]] = i;
}
// logTable[0] == 0 but this should never be used
var at0 = new Array(1); at0[0] = 0;
this.zero = new GF256Poly(this, new Array(at0));
var at1 = new Array(1); at1[0] = 1;
this.one = new GF256Poly(this, new Array(at1));
}
Object.defineProperty(GF256.prototype, "Zero", {
get: function() {
return this.zero;
}
});
Object.defineProperty(GF256.prototype, "One", {
get: function() {
return this.one;
}
});
GF256.prototype.buildMonomial = function(degree, coefficient) {
if (degree < 0) {
throw "System.ArgumentException";
}
if (coefficient == 0) {
return this.zero;
}
var coefficients = new Array(degree + 1);
for (var i = 0; i < coefficients.length; i++)coefficients[i] = 0;
coefficients[0] = coefficient;
return new GF256Poly(this, coefficients);
};
GF256.prototype.exp = function(a) {
return this.expTable[a];
};
GF256.prototype.log = function(a) {
if (a == 0) {
throw "System.ArgumentException";
}
return this.logTable[a];
};
GF256.prototype.inverse = function(a) {
if (a == 0) {
throw "System.ArithmeticException";
}
return this.expTable[255 - this.logTable[a]];
};
GF256.prototype.addOrSubtract = function(a, b) {
return a ^ b;
};
GF256.prototype.multiply = function(a, b) {
if (a == 0 || b == 0) {
return 0;
}
if (a == 1) {
return b;
}
if (b == 1) {
return a;
}
return this.expTable[(this.logTable[a] + this.logTable[b]) % 255];
};
GF256.QR_CODE_FIELD = new GF256(0x011D);
GF256.DATA_MATRIX_FIELD = new GF256(0x012D);
node_modules/qrcode-reader/src/gf256poly.js
Generated Vendored
+192
View File
@@ -0,0 +1,192 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
export default function GF256Poly(field, coefficients) {
if (coefficients == null || coefficients.length == 0) {
throw "System.ArgumentException";
}
this.field = field;
var coefficientsLength = coefficients.length;
if (coefficientsLength > 1 && coefficients[0] == 0) {
// Leading term must be non-zero for anything except the constant polynomial "0"
var firstNonZero = 1;
while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) {
firstNonZero++;
}
if (firstNonZero == coefficientsLength) {
this.coefficients = field.Zero.coefficients;
} else {
this.coefficients = new Array(coefficientsLength - firstNonZero);
for (var i = 0; i < this.coefficients.length; i++) this.coefficients[i] = 0;
for (var ci = 0; ci < this.coefficients.length; ci++) this.coefficients[ci] = coefficients[firstNonZero + ci];
}
} else {
this.coefficients = coefficients;
}
}
Object.defineProperty(GF256Poly.prototype, "Zero", {
get: function() {
return this.coefficients[0] == 0;
}
});
Object.defineProperty(GF256Poly.prototype, "Degree", {
get: function() {
return this.coefficients.length - 1;
}
});
GF256Poly.prototype.getCoefficient = function(degree) {
return this.coefficients[this.coefficients.length - 1 - degree];
};
GF256Poly.prototype.evaluateAt = function(a) {
if (a == 0) {
// Just return the x^0 coefficient
return this.getCoefficient(0);
}
var size = this.coefficients.length;
if (a == 1) {
// Just the sum of the coefficients
var result = 0;
for (var i = 0; i < size; i++) {
result = this.field.addOrSubtract(result, this.coefficients[i]);
}
return result;
}
var result2 = this.coefficients[0];
for (var i = 1; i < size; i++) {
result2 = this.field.addOrSubtract(this.field.multiply(a, result2), this.coefficients[i]);
}
return result2;
};
GF256Poly.prototype.addOrSubtract = function(other) {
if (this.field != other.field) {
throw "GF256Polys do not have same GF256 field";
}
if (this.Zero) {
return other;
}
if (other.Zero) {
return this;
}
var smallerCoefficients = this.coefficients;
var largerCoefficients = other.coefficients;
if (smallerCoefficients.length > largerCoefficients.length) {
var temp = smallerCoefficients;
smallerCoefficients = largerCoefficients;
largerCoefficients = temp;
}
var sumDiff = new Array(largerCoefficients.length);
var lengthDiff = largerCoefficients.length - smallerCoefficients.length;
// Copy high-order terms only found in higher-degree polynomial's coefficients
for (var ci = 0; ci < lengthDiff; ci++)sumDiff[ci] = largerCoefficients[ci];
for (var i = lengthDiff; i < largerCoefficients.length; i++) {
sumDiff[i] = this.field.addOrSubtract(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);
}
return new GF256Poly(this.field, sumDiff);
};
GF256Poly.prototype.multiply1 = function(other) {
if (this.field != other.field) {
throw "GF256Polys do not have same GF256 field";
}
if (this.Zero || other.Zero) {
return this.field.Zero;
}
var aCoefficients = this.coefficients;
var aLength = aCoefficients.length;
var bCoefficients = other.coefficients;
var bLength = bCoefficients.length;
var product = new Array(aLength + bLength - 1);
for (var i = 0; i < aLength; i++) {
var aCoeff = aCoefficients[i];
for (var j = 0; j < bLength; j++) {
product[i + j] = this.field.addOrSubtract(product[i + j], this.field.multiply(aCoeff, bCoefficients[j]));
}
}
return new GF256Poly(this.field, product);
};
GF256Poly.prototype.multiply2 = function(scalar) {
if (scalar == 0) {
return this.field.Zero;
}
if (scalar == 1) {
return this;
}
var size = this.coefficients.length;
var product = new Array(size);
for (var i = 0; i < size; i++) {
product[i] = this.field.multiply(this.coefficients[i], scalar);
}
return new GF256Poly(this.field, product);
};
GF256Poly.prototype.multiplyByMonomial = function(degree, coefficient) {
if (degree < 0) {
throw "System.ArgumentException";
}
if (coefficient == 0) {
return this.field.Zero;
}
var size = this.coefficients.length;
var product = new Array(size + degree);
for (var i = 0; i < product.length; i++)product[i] = 0;
for (var i = 0; i < size; i++) {
product[i] = this.field.multiply(this.coefficients[i], coefficient);
}
return new GF256Poly(this.field, product);
};
GF256Poly.prototype.divide = function(other) {
if (this.field != other.field) {
throw "GF256Polys do not have same GF256 field";
}
if (other.Zero) {
throw "Divide by 0";
}
var quotient = this.field.Zero;
var remainder = this;
var denominatorLeadingTerm = other.getCoefficient(other.Degree);
var inverseDenominatorLeadingTerm = this.field.inverse(denominatorLeadingTerm);
while (remainder.Degree >= other.Degree && !remainder.Zero) {
var degreeDifference = remainder.Degree - other.Degree;
var scale = this.field.multiply(remainder.getCoefficient(remainder.Degree), inverseDenominatorLeadingTerm);
var term = other.multiplyByMonomial(degreeDifference, scale);
var iterationQuotient = this.field.buildMonomial(degreeDifference, scale);
quotient = quotient.addOrSubtract(iterationQuotient);
remainder = remainder.addOrSubtract(term);
}
return [quotient, remainder];
};
node_modules/qrcode-reader/src/grid.js
Generated Vendored
+118
View File
@@ -0,0 +1,118 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
import BitMatrix from './bitmat';
var GridSampler = {};
GridSampler.checkAndNudgePoints = function(image, points) {
var width = image.width;
var height = image.height;
// Check and nudge points from start until we see some that are OK:
var nudged = true;
for (var offset = 0; offset < points.length && nudged; offset += 2) {
var x = Math.floor(points[offset]);
var y = Math.floor(points[offset + 1]);
if (x < -1 || x > width || y < -1 || y > height) {
throw "Error.checkAndNudgePoints ";
}
nudged = false;
if (x == -1) {
points[offset] = 0.0;
nudged = true;
} else if (x == width) {
points[offset] = width - 1;
nudged = true;
}
if (y == -1) {
points[offset + 1] = 0.0;
nudged = true;
} else if (y == height) {
points[offset + 1] = height - 1;
nudged = true;
}
}
// Check and nudge points from end:
nudged = true;
for (var offset = points.length - 2; offset >= 0 && nudged; offset -= 2) {
var x = Math.floor(points[offset]);
var y = Math.floor(points[offset + 1]);
if (x < -1 || x > width || y < -1 || y > height) {
throw "Error.checkAndNudgePoints ";
}
nudged = false;
if (x == -1) {
points[offset] = 0.0;
nudged = true;
} else if (x == width) {
points[offset] = width - 1;
nudged = true;
}
if (y == -1) {
points[offset + 1] = 0.0;
nudged = true;
} else if (y == height) {
points[offset + 1] = height - 1;
nudged = true;
}
}
};
GridSampler.sampleGrid3 = function(image, dimension, transform) {
var bits = new BitMatrix(dimension);
var points = new Array(dimension << 1);
for (var y = 0; y < dimension; y++) {
var max = points.length;
var iValue = y + 0.5;
for (var x = 0; x < max; x += 2) {
points[x] = (x >> 1) + 0.5;
points[x + 1] = iValue;
}
transform.transformPoints1(points);
// Quick check to see if points transformed to something inside the image
// sufficient to check the endpoints
GridSampler.checkAndNudgePoints(image, points);
try {
for (var x = 0; x < max; x += 2) {
var bit = image.data[Math.floor(points[x]) + image.width * Math.floor(points[x + 1])];
if (bit)
bits.set_Renamed(x >> 1, y);
}
} catch (aioobe) {
// This feels wrong, but, sometimes if the finder patterns are misidentified, the resulting
// transform gets "twisted" such that it maps a straight line of points to a set of points
// whose endpoints are in bounds, but others are not. There is probably some mathematical
// way to detect this about the transformation that I don't know yet.
// This results in an ugly runtime exception despite our clever checks above -- can't have
// that. We could check each point's coordinates but that feels duplicative. We settle for
// catching and wrapping ArrayIndexOutOfBoundsException.
throw "Error.checkAndNudgePoints";
}
}
return bits;
};
export default GridSampler;
node_modules/qrcode-reader/src/index.js
Generated Vendored
+3
View File
@@ -0,0 +1,3 @@
import QrCode from './qrcode';
export default QrCode;
node_modules/qrcode-reader/src/qrcode.js
Generated Vendored
+253
View File
@@ -0,0 +1,253 @@
/*
Copyright 2011 Lazar Laszlo (lazarsoft@gmail.com, www.lazarsoft.info)
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.
*/
import Detector from './detector';
import Decoder from './decoder';
export var qrcode = {};
qrcode.sizeOfDataLengthInfo = [[10, 9, 8, 8], [12, 11, 16, 10], [14, 13, 16, 12]];
export default function QrCode() {
this.imagedata = null;
this.width = 0;
this.height = 0;
this.qrCodeSymbol = null;
this.debug = false;
this.callback = null;
}
QrCode.prototype.decode = function(src, data) {
var decode = (function() {
try {
this.error = undefined;
this.result = this.process(this.imagedata);
} catch (e) {
this.error = e;
this.result = undefined;
}
if (this.callback != null) {
this.callback(this.error, this.result);
}
return this.result;
}).bind(this);
if (src != undefined && src.width != undefined) {
/* decode from canvas canvas.context.getImageData */
this.width = src.width;
this.height = src.height;
this.imagedata = {"data": data || src.data};
this.imagedata.width = src.width;
this.imagedata.height = src.height;
decode();
} else {
if (typeof Image === "undefined") {
throw new Error("This source format is not supported in your environment, you need to pass an image buffer with width and height (see https://github.com/edi9999/jsqrcode/blob/master/test/qrcode.js)");
}
/* decode from URL */
var image = new Image();
image.crossOrigin = "Anonymous";
image.onload = (function() {
var canvas_qr = document.createElement('canvas');
var context = canvas_qr.getContext('2d');
var canvas_out = document.getElementById("out-canvas");
if (canvas_out != null) {
var outctx = canvas_out.getContext('2d');
outctx.clearRect(0, 0, 320, 240);
outctx.drawImage(image, 0, 0, 320, 240);
}
canvas_qr.width = image.width;
canvas_qr.height = image.height;
context.drawImage(image, 0, 0);
this.width = image.width;
this.height = image.height;
try {
this.imagedata = context.getImageData(0, 0, image.width, image.height);
} catch (e) {
this.result = "Cross domain image reading not supported in your browser! Save it to your computer then drag and drop the file!";
if (this.callback != null) return this.callback(null, this.result);
}
decode();
}).bind(this);
image.src = src;
}
};
QrCode.prototype.decode_utf8 = function(s) {
return decodeURIComponent(escape(s));
};
QrCode.prototype.process = function(imageData) {
var start = new Date().getTime();
var image = this.grayScaleToBitmap(this.grayscale(imageData));
var detector = new Detector(image);
var qRCodeMatrix = detector.detect();
/*for (var y = 0; y < qRCodeMatrix.bits.height; y++)
{
for (var x = 0; x < qRCodeMatrix.bits.width; x++)
{
var point = (x * 4*2) + (y*2 * imageData.width * 4);
imageData.data[point] = qRCodeMatrix.bits.get_Renamed(x,y)?0:0;
imageData.data[point+1] = qRCodeMatrix.bits.get_Renamed(x,y)?0:0;
imageData.data[point+2] = qRCodeMatrix.bits.get_Renamed(x,y)?255:0;
}
}*/
var reader = Decoder.decode(qRCodeMatrix.bits);
var data = reader.DataByte;
var str = "";
for (var i = 0; i < data.length; i++) {
for (var j = 0; j < data[i].length; j++)
str += String.fromCharCode(data[i][j]);
}
var end = new Date().getTime();
var time = end - start;
if (this.debug) {
console.log('QR Code processing time (ms): ' + time);
}
return {result: this.decode_utf8(str), points: qRCodeMatrix.points};
};
QrCode.prototype.getPixel = function(imageData, x, y) {
if (imageData.width < x) {
throw "point error";
}
if (imageData.height < y) {
throw "point error";
}
var point = (x * 4) + (y * imageData.width * 4);
return (imageData.data[point] * 33 + imageData.data[point + 1] * 34 + imageData.data[point + 2] * 33) / 100;
};
QrCode.prototype.binarize = function(th) {
var ret = new Array(this.width * this.height);
for (var y = 0; y < this.height; y++) {
for (var x = 0; x < this.width; x++) {
var gray = this.getPixel(x, y);
ret[x + y * this.width] = gray <= th;
}
}
return ret;
};
QrCode.prototype.getMiddleBrightnessPerArea = function(imageData) {
var numSqrtArea = 4;
//obtain middle brightness((min + max) / 2) per area
var areaWidth = Math.floor(imageData.width / numSqrtArea);
var areaHeight = Math.floor(imageData.height / numSqrtArea);
var minmax = new Array(numSqrtArea);
for (var i = 0; i < numSqrtArea; i++) {
minmax[i] = new Array(numSqrtArea);
for (var i2 = 0; i2 < numSqrtArea; i2++) {
minmax[i][i2] = [0, 0];
}
}
for (var ay = 0; ay < numSqrtArea; ay++) {
for (var ax = 0; ax < numSqrtArea; ax++) {
minmax[ax][ay][0] = 0xFF;
for (var dy = 0; dy < areaHeight; dy++) {
for (var dx = 0; dx < areaWidth; dx++) {
var target = imageData.data[areaWidth * ax + dx + (areaHeight * ay + dy) * imageData.width];
if (target < minmax[ax][ay][0])
minmax[ax][ay][0] = target;
if (target > minmax[ax][ay][1])
minmax[ax][ay][1] = target;
}
}
}
}
var middle = new Array(numSqrtArea);
for (var i3 = 0; i3 < numSqrtArea; i3++) {
middle[i3] = new Array(numSqrtArea);
}
for (var ay = 0; ay < numSqrtArea; ay++) {
for (var ax = 0; ax < numSqrtArea; ax++) {
middle[ax][ay] = Math.floor((minmax[ax][ay][0] + minmax[ax][ay][1]) / 2);
}
}
return middle;
};
QrCode.prototype.grayScaleToBitmap = function(grayScaleImageData) {
var middle = this.getMiddleBrightnessPerArea(grayScaleImageData);
var sqrtNumArea = middle.length;
var areaWidth = Math.floor(grayScaleImageData.width / sqrtNumArea);
var areaHeight = Math.floor(grayScaleImageData.height / sqrtNumArea);
for (var ay = 0; ay < sqrtNumArea; ay++) {
for (var ax = 0; ax < sqrtNumArea; ax++) {
for (var dy = 0; dy < areaHeight; dy++) {
for (var dx = 0; dx < areaWidth; dx++) {
grayScaleImageData.data[areaWidth * ax + dx + (areaHeight * ay + dy) * grayScaleImageData.width] = (grayScaleImageData.data[areaWidth * ax + dx + (areaHeight * ay + dy) * grayScaleImageData.width] < middle[ax][ay]);
}
}
}
}
return grayScaleImageData;
};
QrCode.prototype.grayscale = function(imageData) {
var ret = new Array(imageData.width * imageData.height);
for (var y = 0; y < imageData.height; y++) {
for (var x = 0; x < imageData.width; x++) {
var gray = this.getPixel(imageData, x, y);
ret[x + y * imageData.width] = gray;
}
}
return {
height: imageData.height,
width: imageData.width,
data: ret
};
};
export function URShift(number, bits) {
if (number >= 0)
return number >> bits;
else
return (number >> bits) + (2 << ~bits);
}
node_modules/qrcode-reader/src/rsdecoder.js
Generated Vendored
+159
View File
@@ -0,0 +1,159 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
import GF256 from './gf256';
import GF256Poly from './gf256poly';
export default function ReedSolomonDecoder(field) {
this.field = field;
}
ReedSolomonDecoder.prototype.decode = function(received, twoS) {
var poly = new GF256Poly(this.field, received);
var syndromeCoefficients = new Array(twoS);
for (var i = 0; i < syndromeCoefficients.length; i++)syndromeCoefficients[i] = 0;
var dataMatrix = false;//this.field.Equals(GF256.DATA_MATRIX_FIELD);
var noError = true;
for (var i = 0; i < twoS; i++) {
// Thanks to sanfordsquires for this fix:
var _eval = poly.evaluateAt(this.field.exp(dataMatrix ? i + 1 : i));
syndromeCoefficients[syndromeCoefficients.length - 1 - i] = _eval;
if (_eval != 0) {
noError = false;
}
}
if (noError) {
return;
}
var syndrome = new GF256Poly(this.field, syndromeCoefficients);
var sigmaOmega = this.runEuclideanAlgorithm(this.field.buildMonomial(twoS, 1), syndrome, twoS);
var sigma = sigmaOmega[0];
var omega = sigmaOmega[1];
var errorLocations = this.findErrorLocations(sigma);
var errorMagnitudes = this.findErrorMagnitudes(omega, errorLocations, dataMatrix);
for (var i = 0; i < errorLocations.length; i++) {
var position = received.length - 1 - this.field.log(errorLocations[i]);
if (position < 0) {
throw "ReedSolomonException Bad error location";
}
received[position] = GF256.prototype.addOrSubtract(received[position], errorMagnitudes[i]);
}
};
ReedSolomonDecoder.prototype.runEuclideanAlgorithm = function(a, b, R) {
// Assume a's degree is >= b's
if (a.Degree < b.Degree) {
var temp = a;
a = b;
b = temp;
}
var rLast = a;
var r = b;
var sLast = this.field.One;
var s = this.field.Zero;
var tLast = this.field.Zero;
var t = this.field.One;
// Run Euclidean algorithm until r's degree is less than R/2
while (r.Degree >= Math.floor(R / 2)) {
var rLastLast = rLast;
var sLastLast = sLast;
var tLastLast = tLast;
rLast = r;
sLast = s;
tLast = t;
// Divide rLastLast by rLast, with quotient in q and remainder in r
if (rLast.Zero) {
// Oops, Euclidean algorithm already terminated?
throw "r_{i-1} was zero";
}
r = rLastLast;
var q = this.field.Zero;
var denominatorLeadingTerm = rLast.getCoefficient(rLast.Degree);
var dltInverse = this.field.inverse(denominatorLeadingTerm);
while (r.Degree >= rLast.Degree && !r.Zero) {
var degreeDiff = r.Degree - rLast.Degree;
var scale = this.field.multiply(r.getCoefficient(r.Degree), dltInverse);
q = q.addOrSubtract(this.field.buildMonomial(degreeDiff, scale));
r = r.addOrSubtract(rLast.multiplyByMonomial(degreeDiff, scale));
}
s = q.multiply1(sLast).addOrSubtract(sLastLast);
t = q.multiply1(tLast).addOrSubtract(tLastLast);
}
var sigmaTildeAtZero = t.getCoefficient(0);
if (sigmaTildeAtZero == 0) {
throw "ReedSolomonException sigmaTilde(0) was zero";
}
var inverse = this.field.inverse(sigmaTildeAtZero);
var sigma = t.multiply2(inverse);
var omega = r.multiply2(inverse);
return [sigma, omega];
};
ReedSolomonDecoder.prototype.findErrorLocations = function(errorLocator) {
// This is a direct application of Chien's search
var numErrors = errorLocator.Degree;
if (numErrors == 1) {
// shortcut
return new Array(errorLocator.getCoefficient(1));
}
var result = new Array(numErrors);
var e = 0;
for (var i = 1; i < 256 && e < numErrors; i++) {
if (errorLocator.evaluateAt(i) == 0) {
result[e] = this.field.inverse(i);
e++;
}
}
if (e != numErrors) {
throw "Error locator degree does not match number of roots";
}
return result;
};
ReedSolomonDecoder.prototype.findErrorMagnitudes = function(errorEvaluator, errorLocations, dataMatrix) {
// This is directly applying Forney's Formula
var s = errorLocations.length;
var result = new Array(s);
for (var i = 0; i < s; i++) {
var xiInverse = this.field.inverse(errorLocations[i]);
var denominator = 1;
for (var j = 0; j < s; j++) {
if (i != j) {
denominator = this.field.multiply(denominator, GF256.prototype.addOrSubtract(1, this.field.multiply(errorLocations[j], xiInverse)));
}
}
result[i] = this.field.multiply(errorEvaluator.evaluateAt(xiInverse), this.field.inverse(denominator));
// Thanks to sanfordsquires for this fix:
if (dataMatrix) {
result[i] = this.field.multiply(result[i], xiInverse);
}
}
return result;
};
node_modules/qrcode-reader/src/version.js
Generated Vendored
+251
View File
@@ -0,0 +1,251 @@
/*
Ported to JavaScript by Lazar Laszlo 2011
lazarsoft@gmail.com, www.lazarsoft.info
*/
/*
*
* 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.
*/
import FormatInformation from './formatinf';
import BitMatrix from './bitmat';
function ECB(count, dataCodewords) {
this.count = count;
this.dataCodewords = dataCodewords;
}
function ECBlocks(ecCodewordsPerBlock, ecBlocks1, ecBlocks2) {
this.ecCodewordsPerBlock = ecCodewordsPerBlock;
if (ecBlocks2)
this.ecBlocks = [ecBlocks1, ecBlocks2];
else
this.ecBlocks = [ecBlocks1];
}
Object.defineProperty(ECBlocks.prototype, "TotalECCodewords", {
get: function() {
return this.ecCodewordsPerBlock * this.NumBlocks;
}
});
Object.defineProperty(ECBlocks.prototype, "NumBlocks", {
get: function() {
var total = 0;
for (var i = 0; i < this.ecBlocks.length; i++) {
total += this.ecBlocks[i].length;
}
return total;
}
});
ECBlocks.prototype.getECBlocks = function() {
return this.ecBlocks;
};
export default function Version(versionNumber, alignmentPatternCenters, ecBlocks1, ecBlocks2, ecBlocks3, ecBlocks4) {
this.versionNumber = versionNumber;
this.alignmentPatternCenters = alignmentPatternCenters;
this.ecBlocks = [ecBlocks1, ecBlocks2, ecBlocks3, ecBlocks4];
var total = 0;
var ecCodewords = ecBlocks1.ecCodewordsPerBlock;
var ecbArray = ecBlocks1.getECBlocks();
for (var i = 0; i < ecbArray.length; i++) {
var ecBlock = ecbArray[i];
total += ecBlock.count * (ecBlock.dataCodewords + ecCodewords);
}
this.totalCodewords = total;
}
Object.defineProperty(Version.prototype, "DimensionForVersion", {
get: function() {
return 17 + 4 * this.versionNumber;
}
});
Version.prototype.buildFunctionPattern = function() {
var dimension = this.DimensionForVersion;
var 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
var max = this.alignmentPatternCenters.length;
for (var x = 0; x < max; x++) {
var i = this.alignmentPatternCenters[x] - 2;
for (var 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;
};
Version.prototype.getECBlocksForLevel = function(ecLevel) {
return this.ecBlocks[ecLevel.ordinal()];
};
Version.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
];
Version.VERSIONS = buildVersions();
Version.getVersionForNumber = function(versionNumber) {
if (versionNumber < 1 || versionNumber > 40) {
throw "ArgumentException";
}
return Version.VERSIONS[versionNumber - 1];
};
Version.getProvisionalVersionForDimension = function(dimension) {
if (dimension % 4 != 1) {
throw "Error getProvisionalVersionForDimension";
}
try {
return Version.getVersionForNumber((dimension - 17) >> 2);
} catch (iae) {
throw "Error getVersionForNumber";
}
};
Version.decodeVersionInformation = function(versionBits) {
var bestDifference = 0xffffffff;
var bestVersion = 0;
for (var i = 0; i < Version.VERSION_DECODE_INFO.length; i++) {
var targetVersion = Version.VERSION_DECODE_INFO[i];
// Do the version info bits match exactly? done.
if (targetVersion == versionBits) {
return this.getVersionForNumber(i + 7);
}
// Otherwise see if this is the closest to a real version info bit string
// we have seen so far
var 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 4 bits.
if (bestDifference <= 3) {
return this.getVersionForNumber(bestVersion);
}
// If we didn't find a close enough match, fail
return null;
};
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, 74, 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))),
];
}
node_modules/qrcode-reader/test/.eslintrc.js
Generated Vendored
+5
View File
@@ -0,0 +1,5 @@
module.exports = {
env: {
"mocha": true,
},
};
node_modules/qrcode-reader/test/image-zxing.png
Generated Vendored
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 971 B

node_modules/qrcode-reader/test/image.png
Generated Vendored
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 845 B

node_modules/qrcode-reader/test/qrcode.js
Generated Vendored
+151
View File
@@ -0,0 +1,151 @@
var expect = require('chai').expect;
var fs = require('fs');
var QrCode = require('../dist/index.js');
var ImageParser = require("image-parser");
const Jimp = require("jimp");
const expectedResult = {
"result": 'Test',
"points": [
{
"count": 2,
"estimatedModuleSize": 8,
"x": 36,
"y": 148,
},
{
"count": 2,
"estimatedModuleSize": 8,
"x": 36,
"y": 36,
},
{
"count": 2,
"estimatedModuleSize": 8,
"x": 148,
"y": 36,
}
]
};
function copy(input) {
return JSON.parse(JSON.stringify(input));
}
it("should work with jimp", function(done) {
var buffer = fs.readFileSync(__dirname + '/image.png');
Jimp.read(buffer, function(err, image) {
if (err) {
return done(err);
}
var qr = new QrCode();
qr.callback = function(err, result) {
if (err) {
return done(err);
}
expect(copy(result)).to.deep.equal(expectedResult);
done();
};
qr.decode(image.bitmap);
});
});
it("should work with a zxing qr code with jimp", function(done) {
var buffer = fs.readFileSync(__dirname + '/image-zxing.png');
Jimp.read(buffer, function(err, image) {
if (err) {
return done(err);
}
var qr = new QrCode();
qr.callback = function(err, result) {
if (err) {
return done(err);
}
expect(copy(result)).to.deep.equal({
"result": 'Test',
"points": [
{
"count": 2,
"estimatedModuleSize": 9,
"x": 34.5,
"y": 160.5,
},
{
"count": 3,
"estimatedModuleSize": 9,
"x": 34.5,
"y": 34.5,
},
{
"count": 2,
"estimatedModuleSize": 9.428571428571429,
"x": 160.5,
"y": 34.5,
}
]
});
done();
};
qr.decode(image.bitmap);
});
});
it('should work with basic image', function(done) {
var buffer = fs.readFileSync(__dirname + '/image.png');
var img = new ImageParser(buffer);
img.parse(function(err) {
if (err) {
return done(err);
}
var qr = new QrCode();
qr.callback = function(err, result) {
if (err) {
return done(err);
}
expect(copy(result)).to.deep.equal(expectedResult);
done();
};
qr.decode({width: img.width(), height: img.height()}, img._imgBuffer);
});
});
it('should work with imageData format', function(done) {
var buffer = fs.readFileSync(__dirname + '/image.png');
var img = new ImageParser(buffer);
img.parse(function(err) {
if (err) {
return done(err);
}
var qr = new QrCode();
qr.callback = function(err, result) {
if (err) {
return done(err);
}
expect(copy(result)).to.deep.equal({
"result": 'Test',
"points": [
{
"count": 2,
"estimatedModuleSize": 8,
"x": 36,
"y": 148,
},
{
"count": 2,
"estimatedModuleSize": 8,
"x": 36,
"y": 36,
},
{
"count": 2,
"estimatedModuleSize": 8,
"x": 148,
"y": 36,
}
]
});
done();
};
qr.decode({height: img.height(), width: img.width(), data: img._imgBuffer});
});
});