devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

小程序实现二维码条形码生成_drawqrcode

作者：正经夜光杯 | 2024-07-30 21:12:19

赞

踩

drawqrcode

  1. <!--index.wxml-->
  2. <view class="container page">
  3.   <view class="panel">
  4.     <view class="header">
  5.     </view>
  6.     <view class="barcode">
  7.       <view class="barnum">{{code}}</view>
  8.       <canvas canvas-id="barcode" />
  9.     </view>
  10.     <view class="qrcode">
  11.       <canvas canvas-id="qrcode" />
  12.     </view>
  13.   </view>
  14. </view>
  15.  
  16. //index.js
  17. var wxbarcode = require('../../utils/index.js');
  18.  
  19. Page({
  20.  
  21.   data: {
  22.     code: '123456'
  23.   },
  24.  
  25.   onLoad: function () {
  26.     wxbarcode.barcode('barcode',this.data.code, 680, 200);
  27.     wxbarcode.qrcode('qrcode', this.data.code, 420, 420);
  28.   }
  29. })
  30.  
  31.  
  32. /**index.wxss**/
  33. page {
  34.     background-color:pink;
  35. }
  36.  
  37. .page {
  38.     display: flex;
  39.     flex-direction: column;
  40.     justify-content: center;
  41.     align-items: center;
  42. }
  43.  
  44. .container {
  45. 	padding-bottom: 10rpx;
  46. }
  47.  
  48. .panel {
  49.     display: flex;
  50.     flex-direction: column;
  51.     justify-content: space-between;
  52.     align-items: stretch;
  53.     box-sizing: border-box;
  54.     width: 710rpx;
  55.     margin-top: 40rpx;
  56.     border-radius: 10rpx;
  57.     background-color: #fff;
  58. }
  59.  
  60. .header {
  61.     height: 140rpx;
  62.     background-color: #f0f0f0;
  63.     border-radius: 10rpx 10rpx 0 0;
  64. }
  65.  
  66. .barcode {
  67.     display: flex;
  68.     height: 320rpx;
  69.     flex-direction: column;
  70.     justify-content: center;
  71.     align-items: center;
  72. }
  73.  
  74. .barnum {
  75.     width: 670rpx;
  76.     height: 100rpx;
  77.     line-height: 100rpx;
  78.     font-size: 38rpx;
  79.     font-weight: bold;
  80.     text-align: center;
  81.     letter-spacing: 10rpx;
  82.     white-space: nowrap;
  83. }
  84.  
  85. .barcode > canvas {
  86.     width: 680rpx;
  87.     height: 200rpx;  
  88. }
  89.  
  90. .qrcode {
  91.     height: 420rpx;
  92.     display: flex;
  93.     flex-direction: column;
  94.     justify-content: flex-end;
  95.     align-items: center;
  96. }
  97.  
  98. .qrcode > canvas {
  99.     width: 420rpx;
  100.     height: 420rpx;
  101. }
  102.  
  1. //index.js
  2.  
  3. // 数字转换二维码 条形码
  4. var barcode = require('./barcode');
  5. var qrcode = require('./qrcode');
  6.  
  7. function convert_length(length) {
  8.   return Math.round(wx.getSystemInfoSync().windowWidth * length / 750);
  9. }
  10.  
  11. function barc(id, code, width, height) {
  12.   barcode.code128(wx.createCanvasContext(id), code, convert_length(width), convert_length(height))
  13. }
  14.  
  15. // 把数字转换成二维码
  16. function toQrcode(canvasId, code, width, height) {
  17.   qrcode.api.draw(code, {
  18.     ctx: wx.createCanvasContext(canvasId),
  19.     width: convert_length(width),
  20.     height: convert_length(height)
  21.   })
  22. }
  23.  
  24.  
  25. module.exports = {
  26.   barcode: barc,
  27.   qrcode:toQrcode
  28. }

 

  1. //引入的插件borcode.js
  2.  
  3. var CHAR_TILDE = 126;
  4. var CODE_FNC1 = 102;
  5.  
  6. var SET_STARTA = 103;
  7. var SET_STARTB = 104;
  8. var SET_STARTC = 105;
  9. var SET_SHIFT = 98;
  10. var SET_CODEA = 101;
  11. var SET_CODEB = 100;
  12. var SET_STOP = 106;
  13.  
  14.  
  15. var REPLACE_CODES = {
  16.   CHAR_TILDE: CODE_FNC1 //~ corresponds to FNC1 in GS1-128 standard
  17. }
  18.  
  19. var CODESET = {
  20.   ANY: 1,
  21.   AB: 2,
  22.   A: 3,
  23.   B: 4,
  24.   C: 5
  25. };
  26.  
  27. function getBytes(str) {
  28.   var bytes = [];
  29.   for (var i = 0; i < str.length; i++) {
  30.     bytes.push(str.charCodeAt(i));
  31.   }
  32.   return bytes;
  33. }
  34.  
  35. exports.code128 = function (ctx, text, width, height) {
  36.  
  37.   width = parseInt(width);
  38.  
  39.   height = parseInt(height);
  40.  
  41.   var codes = stringToCode128(text);
  42.  
  43.   var g = new Graphics(ctx, width, height);
  44.  
  45.   var barWeight = g.area.width / ((codes.length - 3) * 11 + 35);
  46.  
  47.   var x = g.area.left;
  48.   var y = g.area.top;
  49.   for (var i = 0; i < codes.length; i++) {
  50.     var c = codes[i];
  51.     //two bars at a time: 1 black and 1 white
  52.     for (var bar = 0; bar < 8; bar += 2) {
  53.       var barW = PATTERNS[c][bar] * barWeight;
  54.       // var barH = height - y - this.border;
  55.       var barH = height - y;
  56.       var spcW = PATTERNS[c][bar + 1] * barWeight;
  57.  
  58.       //no need to draw if 0 width
  59.       if (barW > 0) {
  60.         g.fillFgRect(x, y, barW, barH);
  61.       }
  62.  
  63.       x += barW + spcW;
  64.     }
  65.   }
  66.  
  67.   ctx.draw();
  68. }
  69.  
  70.  
  71. function stringToCode128(text) {
  72.  
  73.   var barc = {
  74.     currcs: CODESET.C
  75.   };
  76.  
  77.   var bytes = getBytes(text);
  78.   //decide starting codeset
  79.   var index = bytes[0] == CHAR_TILDE ? 1 : 0;
  80.  
  81.   var csa1 = bytes.length > 0 ? codeSetAllowedFor(bytes[index++]) : CODESET.AB;
  82.   var csa2 = bytes.length > 0 ? codeSetAllowedFor(bytes[index++]) : CODESET.AB;
  83.   barc.currcs = getBestStartSet(csa1, csa2);
  84.   barc.currcs = perhapsCodeC(bytes, barc.currcs);
  85.  
  86.   //if no codeset changes this will end up with bytes.length+3
  87.   //start, checksum and stop
  88.   var codes = new Array();
  89.  
  90.   switch (barc.currcs) {
  91.     case CODESET.A:
  92.       codes.push(SET_STARTA);
  93.       break;
  94.     case CODESET.B:
  95.       codes.push(SET_STARTB);
  96.       break;
  97.     default:
  98.       codes.push(SET_STARTC);
  99.       break;
  100.   }
  101.  
  102.  
  103.   for (var i = 0; i < bytes.length; i++) {
  104.     var b1 = bytes[i]; //get the first of a pair
  105.     //should we translate/replace
  106.     if (b1 in REPLACE_CODES) {
  107.       codes.push(REPLACE_CODES[b1]);
  108.       i++ //jump to next
  109.       b1 = bytes[i];
  110.     }
  111.  
  112.     //get the next in the pair if possible
  113.     var b2 = bytes.length > (i + 1) ? bytes[i + 1] : -1;
  114.  
  115.     codes = codes.concat(codesForChar(b1, b2, barc.currcs));
  116.     //code C takes 2 chars each time
  117.     if (barc.currcs == CODESET.C) i++;
  118.   }
  119.  
  120.   //calculate checksum according to Code 128 standards
  121.   var checksum = codes[0];
  122.   for (var weight = 1; weight < codes.length; weight++) {
  123.     checksum += (weight * codes[weight]);
  124.   }
  125.   codes.push(checksum % 103);
  126.  
  127.   codes.push(SET_STOP);
  128.  
  129.   //encoding should now be complete
  130.   return codes;
  131.  
  132.   function getBestStartSet(csa1, csa2) {
  133.     //tries to figure out the best codeset
  134.     //to start with to get the most compact code
  135.     var vote = 0;
  136.     vote += csa1 == CODESET.A ? 1 : 0;
  137.     vote += csa1 == CODESET.B ? -1 : 0;
  138.     vote += csa2 == CODESET.A ? 1 : 0;
  139.     vote += csa2 == CODESET.B ? -1 : 0;
  140.     //tie goes to B due to my own predudices
  141.     return vote > 0 ? CODESET.A : CODESET.B;
  142.   }
  143.  
  144.   function perhapsCodeC(bytes, codeset) {
  145.     for (var i = 0; i < bytes.length; i++) {
  146.       var b = bytes[i]
  147.       if ((b < 48 || b > 57) && b != CHAR_TILDE)
  148.         return codeset;
  149.     }
  150.     return CODESET.C;
  151.   }
  152.  
  153.   //chr1 is current byte
  154.   //chr2 is the next byte to process. looks ahead.
  155.   function codesForChar(chr1, chr2, currcs) {
  156.     var result = [];
  157.     var shifter = -1;
  158.  
  159.     if (charCompatible(chr1, currcs)) {
  160.       if (currcs == CODESET.C) {
  161.         if (chr2 == -1) {
  162.           shifter = SET_CODEB;
  163.           currcs = CODESET.B;
  164.         }
  165.         else if ((chr2 != -1) && !charCompatible(chr2, currcs)) {
  166.           //need to check ahead as well
  167.           if (charCompatible(chr2, CODESET.A)) {
  168.             shifter = SET_CODEA;
  169.             currcs = CODESET.A;
  170.           }
  171.           else {
  172.             shifter = SET_CODEB;
  173.             currcs = CODESET.B;
  174.           }
  175.         }
  176.       }
  177.     }
  178.     else {
  179.       //if there is a next char AND that next char is also not compatible
  180.       if ((chr2 != -1) && !charCompatible(chr2, currcs)) {
  181.         //need to switch code sets
  182.         switch (currcs) {
  183.           case CODESET.A:
  184.             shifter = SET_CODEB;
  185.             currcs = CODESET.B;
  186.             break;
  187.           case CODESET.B:
  188.             shifter = SET_CODEA;
  189.             currcs = CODESET.A;
  190.             break;
  191.         }
  192.       }
  193.       else {
  194.         //no need to shift code sets, a temporary SHIFT will suffice
  195.         shifter = SET_SHIFT;
  196.       }
  197.     }
  198.  
  199.     //ok some type of shift is nessecary
  200.     if (shifter != -1) {
  201.       result.push(shifter);
  202.       result.push(codeValue(chr1));
  203.     }
  204.     else {
  205.       if (currcs == CODESET.C) {
  206.         //include next as well
  207.         result.push(codeValue(chr1, chr2));
  208.       }
  209.       else {
  210.         result.push(codeValue(chr1));
  211.       }
  212.     }
  213.     barc.currcs = currcs;
  214.  
  215.     return result;
  216.   }
  217. }
  218.  
  219. //reduce the ascii code to fit into the Code128 char table
  220. function codeValue(chr1, chr2) {
  221.   if (typeof chr2 == "undefined") {
  222.     return chr1 >= 32 ? chr1 - 32 : chr1 + 64;
  223.   }
  224.   else {
  225.     return parseInt(String.fromCharCode(chr1) + String.fromCharCode(chr2));
  226.   }
  227. }
  228.  
  229. function charCompatible(chr, codeset) {
  230.   var csa = codeSetAllowedFor(chr);
  231.   if (csa == CODESET.ANY) return true;
  232.   //if we need to change from current
  233.   if (csa == CODESET.AB) return true;
  234.   if (csa == CODESET.A && codeset == CODESET.A) return true;
  235.   if (csa == CODESET.B && codeset == CODESET.B) return true;
  236.   return false;
  237. }
  238.  
  239. function codeSetAllowedFor(chr) {
  240.   if (chr >= 48 && chr <= 57) {
  241.     //0-9
  242.     return CODESET.ANY;
  243.   }
  244.   else if (chr >= 32 && chr <= 95) {
  245.     //0-9 A-Z
  246.     return CODESET.AB;
  247.   }
  248.   else {
  249.     //if non printable
  250.     return chr < 32 ? CODESET.A : CODESET.B;
  251.   }
  252. }
  253.  
  254. var Graphics = function (ctx, width, height) {
  255.  
  256.   this.width = width;
  257.   this.height = height;
  258.   this.quiet = Math.round(this.width / 40);
  259.  
  260.   this.border_size = 0;
  261.   this.padding_width = 0;
  262.  
  263.   this.area = {
  264.     width: width - this.padding_width * 2 - this.quiet * 2,
  265.     height: height - this.border_size * 2,
  266.     top: this.border_size - 4,
  267.     left: this.padding_width + this.quiet
  268.   };
  269.  
  270.   this.ctx = ctx;
  271.   this.fg = "#000000";
  272.   this.bg = "#ffffff";
  273.  
  274.   // fill background
  275.   this.fillBgRect(0, 0, width, height);
  276.  
  277.   // fill center to create border
  278.   this.fillBgRect(0, this.border_size, width, height - this.border_size * 2);
  279. }
  280.  
  281. //use native color
  282. Graphics.prototype._fillRect = function (x, y, width, height, color) {
  283.   this.ctx.setFillStyle(color)
  284.   this.ctx.fillRect(x, y, width, height)
  285. }
  286.  
  287. Graphics.prototype.fillFgRect = function (x, y, width, height) {
  288.   this._fillRect(x, y, width, height, this.fg);
  289. }
  290.  
  291. Graphics.prototype.fillBgRect = function (x, y, width, height) {
  292.   this._fillRect(x, y, width, height, this.bg);
  293. }
  294.  
  295. var PATTERNS = [
  296.   [2, 1, 2, 2, 2, 2, 0, 0],  // 0
  297.   [2, 2, 2, 1, 2, 2, 0, 0],  // 1
  298.   [2, 2, 2, 2, 2, 1, 0, 0],  // 2
  299.   [1, 2, 1, 2, 2, 3, 0, 0],  // 3
  300.   [1, 2, 1, 3, 2, 2, 0, 0],  // 4
  301.   [1, 3, 1, 2, 2, 2, 0, 0],  // 5
  302.   [1, 2, 2, 2, 1, 3, 0, 0],  // 6
  303.   [1, 2, 2, 3, 1, 2, 0, 0],  // 7
  304.   [1, 3, 2, 2, 1, 2, 0, 0],  // 8
  305.   [2, 2, 1, 2, 1, 3, 0, 0],  // 9
  306.   [2, 2, 1, 3, 1, 2, 0, 0],  // 10
  307.   [2, 3, 1, 2, 1, 2, 0, 0],  // 11
  308.   [1, 1, 2, 2, 3, 2, 0, 0],  // 12
  309.   [1, 2, 2, 1, 3, 2, 0, 0],  // 13
  310.   [1, 2, 2, 2, 3, 1, 0, 0],  // 14
  311.   [1, 1, 3, 2, 2, 2, 0, 0],  // 15
  312.   [1, 2, 3, 1, 2, 2, 0, 0],  // 16
  313.   [1, 2, 3, 2, 2, 1, 0, 0],  // 17
  314.   [2, 2, 3, 2, 1, 1, 0, 0],  // 18
  315.   [2, 2, 1, 1, 3, 2, 0, 0],  // 19
  316.   [2, 2, 1, 2, 3, 1, 0, 0],  // 20
  317.   [2, 1, 3, 2, 1, 2, 0, 0],  // 21
  318.   [2, 2, 3, 1, 1, 2, 0, 0],  // 22
  319.   [3, 1, 2, 1, 3, 1, 0, 0],  // 23
  320.   [3, 1, 1, 2, 2, 2, 0, 0],  // 24
  321.   [3, 2, 1, 1, 2, 2, 0, 0],  // 25
  322.   [3, 2, 1, 2, 2, 1, 0, 0],  // 26
  323.   [3, 1, 2, 2, 1, 2, 0, 0],  // 27
  324.   [3, 2, 2, 1, 1, 2, 0, 0],  // 28
  325.   [3, 2, 2, 2, 1, 1, 0, 0],  // 29
  326.   [2, 1, 2, 1, 2, 3, 0, 0],  // 30
  327.   [2, 1, 2, 3, 2, 1, 0, 0],  // 31
  328.   [2, 3, 2, 1, 2, 1, 0, 0],  // 32
  329.   [1, 1, 1, 3, 2, 3, 0, 0],  // 33
  330.   [1, 3, 1, 1, 2, 3, 0, 0],  // 34
  331.   [1, 3, 1, 3, 2, 1, 0, 0],  // 35
  332.   [1, 1, 2, 3, 1, 3, 0, 0],  // 36
  333.   [1, 3, 2, 1, 1, 3, 0, 0],  // 37
  334.   [1, 3, 2, 3, 1, 1, 0, 0],  // 38
  335.   [2, 1, 1, 3, 1, 3, 0, 0],  // 39
  336.   [2, 3, 1, 1, 1, 3, 0, 0],  // 40
  337.   [2, 3, 1, 3, 1, 1, 0, 0],  // 41
  338.   [1, 1, 2, 1, 3, 3, 0, 0],  // 42
  339.   [1, 1, 2, 3, 3, 1, 0, 0],  // 43
  340.   [1, 3, 2, 1, 3, 1, 0, 0],  // 44
  341.   [1, 1, 3, 1, 2, 3, 0, 0],  // 45
  342.   [1, 1, 3, 3, 2, 1, 0, 0],  // 46
  343.   [1, 3, 3, 1, 2, 1, 0, 0],  // 47
  344.   [3, 1, 3, 1, 2, 1, 0, 0],  // 48
  345.   [2, 1, 1, 3, 3, 1, 0, 0],  // 49
  346.   [2, 3, 1, 1, 3, 1, 0, 0],  // 50
  347.   [2, 1, 3, 1, 1, 3, 0, 0],  // 51
  348.   [2, 1, 3, 3, 1, 1, 0, 0],  // 52
  349.   [2, 1, 3, 1, 3, 1, 0, 0],  // 53
  350.   [3, 1, 1, 1, 2, 3, 0, 0],  // 54
  351.   [3, 1, 1, 3, 2, 1, 0, 0],  // 55
  352.   [3, 3, 1, 1, 2, 1, 0, 0],  // 56
  353.   [3, 1, 2, 1, 1, 3, 0, 0],  // 57
  354.   [3, 1, 2, 3, 1, 1, 0, 0],  // 58
  355.   [3, 3, 2, 1, 1, 1, 0, 0],  // 59
  356.   [3, 1, 4, 1, 1, 1, 0, 0],  // 60
  357.   [2, 2, 1, 4, 1, 1, 0, 0],  // 61
  358.   [4, 3, 1, 1, 1, 1, 0, 0],  // 62
  359.   [1, 1, 1, 2, 2, 4, 0, 0],  // 63
  360.   [1, 1, 1, 4, 2, 2, 0, 0],  // 64
  361.   [1, 2, 1, 1, 2, 4, 0, 0],  // 65
  362.   [1, 2, 1, 4, 2, 1, 0, 0],  // 66
  363.   [1, 4, 1, 1, 2, 2, 0, 0],  // 67
  364.   [1, 4, 1, 2, 2, 1, 0, 0],  // 68
  365.   [1, 1, 2, 2, 1, 4, 0, 0],  // 69
  366.   [1, 1, 2, 4, 1, 2, 0, 0],  // 70
  367.   [1, 2, 2, 1, 1, 4, 0, 0],  // 71
  368.   [1, 2, 2, 4, 1, 1, 0, 0],  // 72
  369.   [1, 4, 2, 1, 1, 2, 0, 0],  // 73
  370.   [1, 4, 2, 2, 1, 1, 0, 0],  // 74
  371.   [2, 4, 1, 2, 1, 1, 0, 0],  // 75
  372.   [2, 2, 1, 1, 1, 4, 0, 0],  // 76
  373.   [4, 1, 3, 1, 1, 1, 0, 0],  // 77
  374.   [2, 4, 1, 1, 1, 2, 0, 0],  // 78
  375.   [1, 3, 4, 1, 1, 1, 0, 0],  // 79
  376.   [1, 1, 1, 2, 4, 2, 0, 0],  // 80
  377.   [1, 2, 1, 1, 4, 2, 0, 0],  // 81
  378.   [1, 2, 1, 2, 4, 1, 0, 0],  // 82
  379.   [1, 1, 4, 2, 1, 2, 0, 0],  // 83
  380.   [1, 2, 4, 1, 1, 2, 0, 0],  // 84
  381.   [1, 2, 4, 2, 1, 1, 0, 0],  // 85
  382.   [4, 1, 1, 2, 1, 2, 0, 0],  // 86
  383.   [4, 2, 1, 1, 1, 2, 0, 0],  // 87
  384.   [4, 2, 1, 2, 1, 1, 0, 0],  // 88
  385.   [2, 1, 2, 1, 4, 1, 0, 0],  // 89
  386.   [2, 1, 4, 1, 2, 1, 0, 0],  // 90
  387.   [4, 1, 2, 1, 2, 1, 0, 0],  // 91
  388.   [1, 1, 1, 1, 4, 3, 0, 0],  // 92
  389.   [1, 1, 1, 3, 4, 1, 0, 0],  // 93
  390.   [1, 3, 1, 1, 4, 1, 0, 0],  // 94
  391.   [1, 1, 4, 1, 1, 3, 0, 0],  // 95
  392.   [1, 1, 4, 3, 1, 1, 0, 0],  // 96
  393.   [4, 1, 1, 1, 1, 3, 0, 0],  // 97
  394.   [4, 1, 1, 3, 1, 1, 0, 0],  // 98
  395.   [1, 1, 3, 1, 4, 1, 0, 0],  // 99
  396.   [1, 1, 4, 1, 3, 1, 0, 0],  // 100
  397.   [3, 1, 1, 1, 4, 1, 0, 0],  // 101
  398.   [4, 1, 1, 1, 3, 1, 0, 0],  // 102
  399.   [2, 1, 1, 4, 1, 2, 0, 0],  // 103
  400.   [2, 1, 1, 2, 1, 4, 0, 0],  // 104
  401.   [2, 1, 1, 2, 3, 2, 0, 0],  // 105
  402.   [2, 3, 3, 1, 1, 1, 2, 0]   // 106
  403. ]
  404.

 

  1. //引入的插件qrcode.js
  2.  
  3. var QR = (function () {
  4.  
  5.   // alignment pattern
  6.   var adelta = [
  7.     0, 11, 15, 19, 23, 27, 31, // force 1 pat
  8.     16, 18, 20, 22, 24, 26, 28, 20, 22, 24, 24, 26, 28, 28, 22, 24, 24,
  9.     26, 26, 28, 28, 24, 24, 26, 26, 26, 28, 28, 24, 26, 26, 26, 28, 28
  10.   ];
  11.  
  12.   // version block
  13.   var vpat = [
  14.     0xc94, 0x5bc, 0xa99, 0x4d3, 0xbf6, 0x762, 0x847, 0x60d,
  15.     0x928, 0xb78, 0x45d, 0xa17, 0x532, 0x9a6, 0x683, 0x8c9,
  16.     0x7ec, 0xec4, 0x1e1, 0xfab, 0x08e, 0xc1a, 0x33f, 0xd75,
  17.     0x250, 0x9d5, 0x6f0, 0x8ba, 0x79f, 0xb0b, 0x42e, 0xa64,
  18.     0x541, 0xc69
  19.   ];
  20.  
  21.   // final format bits with mask: level << 3 | mask
  22.   var fmtword = [
  23.     0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976,    //L
  24.     0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0,    //M
  25.     0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed,    //Q
  26.     0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b    //H
  27.   ];
  28.  
  29.   // 4 per version: number of blocks 1,2; data width; ecc width
  30.   var eccblocks = [
  31.     1, 0, 19, 7, 1, 0, 16, 10, 1, 0, 13, 13, 1, 0, 9, 17,
  32.     1, 0, 34, 10, 1, 0, 28, 16, 1, 0, 22, 22, 1, 0, 16, 28,
  33.     1, 0, 55, 15, 1, 0, 44, 26, 2, 0, 17, 18, 2, 0, 13, 22,
  34.     1, 0, 80, 20, 2, 0, 32, 18, 2, 0, 24, 26, 4, 0, 9, 16,
  35.     1, 0, 108, 26, 2, 0, 43, 24, 2, 2, 15, 18, 2, 2, 11, 22,
  36.     2, 0, 68, 18, 4, 0, 27, 16, 4, 0, 19, 24, 4, 0, 15, 28,
  37.     2, 0, 78, 20, 4, 0, 31, 18, 2, 4, 14, 18, 4, 1, 13, 26,
  38.     2, 0, 97, 24, 2, 2, 38, 22, 4, 2, 18, 22, 4, 2, 14, 26,
  39.     2, 0, 116, 30, 3, 2, 36, 22, 4, 4, 16, 20, 4, 4, 12, 24,
  40.     2, 2, 68, 18, 4, 1, 43, 26, 6, 2, 19, 24, 6, 2, 15, 28,
  41.     4, 0, 81, 20, 1, 4, 50, 30, 4, 4, 22, 28, 3, 8, 12, 24,
  42.     2, 2, 92, 24, 6, 2, 36, 22, 4, 6, 20, 26, 7, 4, 14, 28,
  43.     4, 0, 107, 26, 8, 1, 37, 22, 8, 4, 20, 24, 12, 4, 11, 22,
  44.     3, 1, 115, 30, 4, 5, 40, 24, 11, 5, 16, 20, 11, 5, 12, 24,
  45.     5, 1, 87, 22, 5, 5, 41, 24, 5, 7, 24, 30, 11, 7, 12, 24,
  46.     5, 1, 98, 24, 7, 3, 45, 28, 15, 2, 19, 24, 3, 13, 15, 30,
  47.     1, 5, 107, 28, 10, 1, 46, 28, 1, 15, 22, 28, 2, 17, 14, 28,
  48.     5, 1, 120, 30, 9, 4, 43, 26, 17, 1, 22, 28, 2, 19, 14, 28,
  49.     3, 4, 113, 28, 3, 11, 44, 26, 17, 4, 21, 26, 9, 16, 13, 26,
  50.     3, 5, 107, 28, 3, 13, 41, 26, 15, 5, 24, 30, 15, 10, 15, 28,
  51.     4, 4, 116, 28, 17, 0, 42, 26, 17, 6, 22, 28, 19, 6, 16, 30,
  52.     2, 7, 111, 28, 17, 0, 46, 28, 7, 16, 24, 30, 34, 0, 13, 24,
  53.     4, 5, 121, 30, 4, 14, 47, 28, 11, 14, 24, 30, 16, 14, 15, 30,
  54.     6, 4, 117, 30, 6, 14, 45, 28, 11, 16, 24, 30, 30, 2, 16, 30,
  55.     8, 4, 106, 26, 8, 13, 47, 28, 7, 22, 24, 30, 22, 13, 15, 30,
  56.     10, 2, 114, 28, 19, 4, 46, 28, 28, 6, 22, 28, 33, 4, 16, 30,
  57.     8, 4, 122, 30, 22, 3, 45, 28, 8, 26, 23, 30, 12, 28, 15, 30,
  58.     3, 10, 117, 30, 3, 23, 45, 28, 4, 31, 24, 30, 11, 31, 15, 30,
  59.     7, 7, 116, 30, 21, 7, 45, 28, 1, 37, 23, 30, 19, 26, 15, 30,
  60.     5, 10, 115, 30, 19, 10, 47, 28, 15, 25, 24, 30, 23, 25, 15, 30,
  61.     13, 3, 115, 30, 2, 29, 46, 28, 42, 1, 24, 30, 23, 28, 15, 30,
  62.     17, 0, 115, 30, 10, 23, 46, 28, 10, 35, 24, 30, 19, 35, 15, 30,
  63.     17, 1, 115, 30, 14, 21, 46, 28, 29, 19, 24, 30, 11, 46, 15, 30,
  64.     13, 6, 115, 30, 14, 23, 46, 28, 44, 7, 24, 30, 59, 1, 16, 30,
  65.     12, 7, 121, 30, 12, 26, 47, 28, 39, 14, 24, 30, 22, 41, 15, 30,
  66.     6, 14, 121, 30, 6, 34, 47, 28, 46, 10, 24, 30, 2, 64, 15, 30,
  67.     17, 4, 122, 30, 29, 14, 46, 28, 49, 10, 24, 30, 24, 46, 15, 30,
  68.     4, 18, 122, 30, 13, 32, 46, 28, 48, 14, 24, 30, 42, 32, 15, 30,
  69.     20, 4, 117, 30, 40, 7, 47, 28, 43, 22, 24, 30, 10, 67, 15, 30,
  70.     19, 6, 118, 30, 18, 31, 47, 28, 34, 34, 24, 30, 20, 61, 15, 30
  71.   ];
  72.  
  73.   // Galois field log table
  74.   var glog = [
  75.     0xff, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
  76.     0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81, 0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
  77.     0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21, 0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
  78.     0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9, 0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
  79.     0x06, 0xbf, 0x8b, 0x62, 0x66, 0xdd, 0x30, 0xfd, 0xe2, 0x98, 0x25, 0xb3, 0x10, 0x91, 0x22, 0x88,
  80.     0x36, 0xd0, 0x94, 0xce, 0x8f, 0x96, 0xdb, 0xbd, 0xf1, 0xd2, 0x13, 0x5c, 0x83, 0x38, 0x46, 0x40,
  81.     0x1e, 0x42, 0xb6, 0xa3, 0xc3, 0x48, 0x7e, 0x6e, 0x6b, 0x3a, 0x28, 0x54, 0xfa, 0x85, 0xba, 0x3d,
  82.     0xca, 0x5e, 0x9b, 0x9f, 0x0a, 0x15, 0x79, 0x2b, 0x4e, 0xd4, 0xe5, 0xac, 0x73, 0xf3, 0xa7, 0x57,
  83.     0x07, 0x70, 0xc0, 0xf7, 0x8c, 0x80, 0x63, 0x0d, 0x67, 0x4a, 0xde, 0xed, 0x31, 0xc5, 0xfe, 0x18,
  84.     0xe3, 0xa5, 0x99, 0x77, 0x26, 0xb8, 0xb4, 0x7c, 0x11, 0x44, 0x92, 0xd9, 0x23, 0x20, 0x89, 0x2e,
  85.     0x37, 0x3f, 0xd1, 0x5b, 0x95, 0xbc, 0xcf, 0xcd, 0x90, 0x87, 0x97, 0xb2, 0xdc, 0xfc, 0xbe, 0x61,
  86.     0xf2, 0x56, 0xd3, 0xab, 0x14, 0x2a, 0x5d, 0x9e, 0x84, 0x3c, 0x39, 0x53, 0x47, 0x6d, 0x41, 0xa2,
  87.     0x1f, 0x2d, 0x43, 0xd8, 0xb7, 0x7b, 0xa4, 0x76, 0xc4, 0x17, 0x49, 0xec, 0x7f, 0x0c, 0x6f, 0xf6,
  88.     0x6c, 0xa1, 0x3b, 0x52, 0x29, 0x9d, 0x55, 0xaa, 0xfb, 0x60, 0x86, 0xb1, 0xbb, 0xcc, 0x3e, 0x5a,
  89.     0xcb, 0x59, 0x5f, 0xb0, 0x9c, 0xa9, 0xa0, 0x51, 0x0b, 0xf5, 0x16, 0xeb, 0x7a, 0x75, 0x2c, 0xd7,
  90.     0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8, 0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf
  91.   ];
  92.  
  93.   // Galios field exponent table
  94.   var gexp = [
  95.     0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
  96.     0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9, 0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
  97.     0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35, 0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
  98.     0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0, 0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
  99.     0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc, 0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0,
  100.     0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f, 0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2,
  101.     0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88, 0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce,
  102.     0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93, 0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc,
  103.     0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9, 0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54,
  104.     0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa, 0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73,
  105.     0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e, 0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff,
  106.     0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4, 0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
  107.     0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
  108.     0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef, 0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
  109.     0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5, 0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
  110.     0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83, 0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x00
  111.   ];
  112.  
  113.   // Working buffers:
  114.   // data input and ecc append, image working buffer, fixed part of image, run lengths for badness
  115.   var strinbuf = [], eccbuf = [], qrframe = [], framask = [], rlens = [];
  116.   // Control values - width is based on version, last 4 are from table.
  117.   var version, width, neccblk1, neccblk2, datablkw, eccblkwid;
  118.   var ecclevel = 2;
  119.   // set bit to indicate cell in qrframe is immutable.  symmetric around diagonal
  120.   function setmask(x, y) {
  121.     var bt;
  122.     if (x > y) {
  123.       bt = x;
  124.       x = y;
  125.       y = bt;
  126.     }
  127.     // y*y = 1+3+5...
  128.     bt = y;
  129.     bt *= y;
  130.     bt += y;
  131.     bt >>= 1;
  132.     bt += x;
  133.     framask[bt] = 1;
  134.   }
  135.  
  136.   // enter alignment pattern - black to qrframe, white to mask (later black frame merged to mask)
  137.   function putalign(x, y) {
  138.     var j;
  139.  
  140.     qrframe[x + width * y] = 1;
  141.     for (j = -2; j < 2; j++) {
  142.       qrframe[(x + j) + width * (y - 2)] = 1;
  143.       qrframe[(x - 2) + width * (y + j + 1)] = 1;
  144.       qrframe[(x + 2) + width * (y + j)] = 1;
  145.       qrframe[(x + j + 1) + width * (y + 2)] = 1;
  146.     }
  147.     for (j = 0; j < 2; j++) {
  148.       setmask(x - 1, y + j);
  149.       setmask(x + 1, y - j);
  150.       setmask(x - j, y - 1);
  151.       setmask(x + j, y + 1);
  152.     }
  153.   }
  154.  
  155.   //========================================================================
  156.   // Reed Solomon error correction
  157.   // exponentiation mod N
  158.   function modnn(x) {
  159.     while (x >= 255) {
  160.       x -= 255;
  161.       x = (x >> 8) + (x & 255);
  162.     }
  163.     return x;
  164.   }
  165.  
  166.   var genpoly = [];
  167.  
  168.   // Calculate and append ECC data to data block.  Block is in strinbuf, indexes to buffers given.
  169.   function appendrs(data, dlen, ecbuf, eclen) {
  170.     var i, j, fb;
  171.  
  172.     for (i = 0; i < eclen; i++)
  173.       strinbuf[ecbuf + i] = 0;
  174.     for (i = 0; i < dlen; i++) {
  175.       fb = glog[strinbuf[data + i] ^ strinbuf[ecbuf]];
  176.       if (fb != 255)     /* fb term is non-zero */
  177.         for (j = 1; j < eclen; j++)
  178.           strinbuf[ecbuf + j - 1] = strinbuf[ecbuf + j] ^ gexp[modnn(fb + genpoly[eclen - j])];
  179.       else
  180.         for (j = ecbuf; j < ecbuf + eclen; j++)
  181.           strinbuf[j] = strinbuf[j + 1];
  182.       strinbuf[ecbuf + eclen - 1] = fb == 255 ? 0 : gexp[modnn(fb + genpoly[0])];
  183.     }
  184.   }
  185.  
  186.   //========================================================================
  187.   // Frame data insert following the path rules
  188.  
  189.   // check mask - since symmetrical use half.
  190.   function ismasked(x, y) {
  191.     var bt;
  192.     if (x > y) {
  193.       bt = x;
  194.       x = y;
  195.       y = bt;
  196.     }
  197.     bt = y;
  198.     bt += y * y;
  199.     bt >>= 1;
  200.     bt += x;
  201.     return framask[bt];
  202.   }
  203.  
  204.   //========================================================================
  205.   //  Apply the selected mask out of the 8.
  206.   function applymask(m) {
  207.     var x, y, r3x, r3y;
  208.  
  209.     switch (m) {
  210.       case 0:
  211.         for (y = 0; y < width; y++)
  212.           for (x = 0; x < width; x++)
  213.             if (!((x + y) & 1) && !ismasked(x, y))
  214.               qrframe[x + y * width] ^= 1;
  215.         break;
  216.       case 1:
  217.         for (y = 0; y < width; y++)
  218.           for (x = 0; x < width; x++)
  219.             if (!(y & 1) && !ismasked(x, y))
  220.               qrframe[x + y * width] ^= 1;
  221.         break;
  222.       case 2:
  223.         for (y = 0; y < width; y++)
  224.           for (r3x = 0, x = 0; x < width; x++ , r3x++) {
  225.             if (r3x == 3)
  226.               r3x = 0;
  227.             if (!r3x && !ismasked(x, y))
  228.               qrframe[x + y * width] ^= 1;
  229.           }
  230.         break;
  231.       case 3:
  232.         for (r3y = 0, y = 0; y < width; y++ , r3y++) {
  233.           if (r3y == 3)
  234.             r3y = 0;
  235.           for (r3x = r3y, x = 0; x < width; x++ , r3x++) {
  236.             if (r3x == 3)
  237.               r3x = 0;
  238.             if (!r3x && !ismasked(x, y))
  239.               qrframe[x + y * width] ^= 1;
  240.           }
  241.         }
  242.         break;
  243.       case 4:
  244.         for (y = 0; y < width; y++)
  245.           for (r3x = 0, r3y = ((y >> 1) & 1), x = 0; x < width; x++ , r3x++) {
  246.             if (r3x == 3) {
  247.               r3x = 0;
  248.               r3y = !r3y;
  249.             }
  250.             if (!r3y && !ismasked(x, y))
  251.               qrframe[x + y * width] ^= 1;
  252.           }
  253.         break;
  254.       case 5:
  255.         for (r3y = 0, y = 0; y < width; y++ , r3y++) {
  256.           if (r3y == 3)
  257.             r3y = 0;
  258.           for (r3x = 0, x = 0; x < width; x++ , r3x++) {
  259.             if (r3x == 3)
  260.               r3x = 0;
  261.             if (!((x & y & 1) + !(!r3x | !r3y)) && !ismasked(x, y))
  262.               qrframe[x + y * width] ^= 1;
  263.           }
  264.         }
  265.         break;
  266.       case 6:
  267.         for (r3y = 0, y = 0; y < width; y++ , r3y++) {
  268.           if (r3y == 3)
  269.             r3y = 0;
  270.           for (r3x = 0, x = 0; x < width; x++ , r3x++) {
  271.             if (r3x == 3)
  272.               r3x = 0;
  273.             if (!(((x & y & 1) + (r3x && (r3x == r3y))) & 1) && !ismasked(x, y))
  274.               qrframe[x + y * width] ^= 1;
  275.           }
  276.         }
  277.         break;
  278.       case 7:
  279.         for (r3y = 0, y = 0; y < width; y++ , r3y++) {
  280.           if (r3y == 3)
  281.             r3y = 0;
  282.           for (r3x = 0, x = 0; x < width; x++ , r3x++) {
  283.             if (r3x == 3)
  284.               r3x = 0;
  285.             if (!(((r3x && (r3x == r3y)) + ((x + y) & 1)) & 1) && !ismasked(x, y))
  286.               qrframe[x + y * width] ^= 1;
  287.           }
  288.         }
  289.         break;
  290.     }
  291.     return;
  292.   }
  293.  
  294.   // Badness coefficients.
  295.   var N1 = 3, N2 = 3, N3 = 40, N4 = 10;
  296.  
  297.   // Using the table of the length of each run, calculate the amount of bad image 
  298.   // - long runs or those that look like finders; called twice, once each for X and Y
  299.   function badruns(length) {
  300.     var i;
  301.     var runsbad = 0;
  302.     for (i = 0; i <= length; i++)
  303.       if (rlens[i] >= 5)
  304.         runsbad += N1 + rlens[i] - 5;
  305.     // BwBBBwB as in finder
  306.     for (i = 3; i < length - 1; i += 2)
  307.       if (rlens[i - 2] == rlens[i + 2]
  308.         && rlens[i + 2] == rlens[i - 1]
  309.         && rlens[i - 1] == rlens[i + 1]
  310.         && rlens[i - 1] * 3 == rlens[i]
  311.         // white around the black pattern? Not part of spec
  312.         && (rlens[i - 3] == 0 // beginning
  313.           || i + 3 > length  // end
  314.           || rlens[i - 3] * 3 >= rlens[i] * 4 || rlens[i + 3] * 3 >= rlens[i] * 4)
  315.       )
  316.         runsbad += N3;
  317.     return runsbad;
  318.   }
  319.  
  320.   // Calculate how bad the masked image is - blocks, imbalance, runs, or finders.
  321.   function badcheck() {
  322.     var x, y, h, b, b1;
  323.     var thisbad = 0;
  324.     var bw = 0;
  325.  
  326.     // blocks of same color.
  327.     for (y = 0; y < width - 1; y++)
  328.       for (x = 0; x < width - 1; x++)
  329.         if ((qrframe[x + width * y] && qrframe[(x + 1) + width * y]
  330.           && qrframe[x + width * (y + 1)] && qrframe[(x + 1) + width * (y + 1)]) // all black
  331.           || !(qrframe[x + width * y] || qrframe[(x + 1) + width * y]
  332.             || qrframe[x + width * (y + 1)] || qrframe[(x + 1) + width * (y + 1)])) // all white
  333.           thisbad += N2;
  334.  
  335.     // X runs
  336.     for (y = 0; y < width; y++) {
  337.       rlens[0] = 0;
  338.       for (h = b = x = 0; x < width; x++) {
  339.         if ((b1 = qrframe[x + width * y]) == b)
  340.           rlens[h]++;
  341.         else
  342.           rlens[++h] = 1;
  343.         b = b1;
  344.         bw += b ? 1 : -1;
  345.       }
  346.       thisbad += badruns(h);
  347.     }
  348.  
  349.     // black/white imbalance
  350.     if (bw < 0)
  351.       bw = -bw;
  352.  
  353.     var big = bw;
  354.     var count = 0;
  355.     big += big << 2;
  356.     big <<= 1;
  357.     while (big > width * width)
  358.       big -= width * width, count++;
  359.     thisbad += count * N4;
  360.  
  361.     // Y runs
  362.     for (x = 0; x < width; x++) {
  363.       rlens[0] = 0;
  364.       for (h = b = y = 0; y < width; y++) {
  365.         if ((b1 = qrframe[x + width * y]) == b)
  366.           rlens[h]++;
  367.         else
  368.           rlens[++h] = 1;
  369.         b = b1;
  370.       }
  371.       thisbad += badruns(h);
  372.     }
  373.     return thisbad;
  374.   }
  375.  
  376.   function genframe(instring) {
  377.     var x, y, k, t, v, i, j, m;
  378.  
  379.     // find the smallest version that fits the string
  380.     t = instring.length;
  381.     version = 0;
  382.     do {
  383.       version++;
  384.       k = (ecclevel - 1) * 4 + (version - 1) * 16;
  385.       neccblk1 = eccblocks[k++];
  386.       neccblk2 = eccblocks[k++];
  387.       datablkw = eccblocks[k++];
  388.       eccblkwid = eccblocks[k];
  389.       k = datablkw * (neccblk1 + neccblk2) + neccblk2 - 3 + (version <= 9);
  390.       if (t <= k)
  391.         break;
  392.     } while (version < 40);
  393.  
  394.     // FIXME - insure that it fits insted of being truncated
  395.     width = 17 + 4 * version;
  396.  
  397.     // allocate, clear and setup data structures
  398.     v = datablkw + (datablkw + eccblkwid) * (neccblk1 + neccblk2) + neccblk2;
  399.     for (t = 0; t < v; t++)
  400.       eccbuf[t] = 0;
  401.     strinbuf = instring.slice(0);
  402.  
  403.     for (t = 0; t < width * width; t++)
  404.       qrframe[t] = 0;
  405.  
  406.     for (t = 0; t < (width * (width + 1) + 1) / 2; t++)
  407.       framask[t] = 0;
  408.  
  409.     // insert finders - black to frame, white to mask
  410.     for (t = 0; t < 3; t++) {
  411.       k = 0;
  412.       y = 0;
  413.       if (t == 1)
  414.         k = (width - 7);
  415.       if (t == 2)
  416.         y = (width - 7);
  417.       qrframe[(y + 3) + width * (k + 3)] = 1;
  418.       for (x = 0; x < 6; x++) {
  419.         qrframe[(y + x) + width * k] = 1;
  420.         qrframe[y + width * (k + x + 1)] = 1;
  421.         qrframe[(y + 6) + width * (k + x)] = 1;
  422.         qrframe[(y + x + 1) + width * (k + 6)] = 1;
  423.       }
  424.       for (x = 1; x < 5; x++) {
  425.         setmask(y + x, k + 1);
  426.         setmask(y + 1, k + x + 1);
  427.         setmask(y + 5, k + x);
  428.         setmask(y + x + 1, k + 5);
  429.       }
  430.       for (x = 2; x < 4; x++) {
  431.         qrframe[(y + x) + width * (k + 2)] = 1;
  432.         qrframe[(y + 2) + width * (k + x + 1)] = 1;
  433.         qrframe[(y + 4) + width * (k + x)] = 1;
  434.         qrframe[(y + x + 1) + width * (k + 4)] = 1;
  435.       }
  436.     }
  437.  
  438.     // alignment blocks
  439.     if (version > 1) {
  440.       t = adelta[version];
  441.       y = width - 7;
  442.       for (; ;) {
  443.         x = width - 7;
  444.         while (x > t - 3) {
  445.           putalign(x, y);
  446.           if (x < t)
  447.             break;
  448.           x -= t;
  449.         }
  450.         if (y <= t + 9)
  451.           break;
  452.         y -= t;
  453.         putalign(6, y);
  454.         putalign(y, 6);
  455.       }
  456.     }
  457.  
  458.     // single black
  459.     qrframe[8 + width * (width - 8)] = 1;
  460.  
  461.     // timing gap - mask only
  462.     for (y = 0; y < 7; y++) {
  463.       setmask(7, y);
  464.       setmask(width - 8, y);
  465.       setmask(7, y + width - 7);
  466.     }
  467.     for (x = 0; x < 8; x++) {
  468.       setmask(x, 7);
  469.       setmask(x + width - 8, 7);
  470.       setmask(x, width - 8);
  471.     }
  472.  
  473.     // reserve mask-format area
  474.     for (x = 0; x < 9; x++)
  475.       setmask(x, 8);
  476.     for (x = 0; x < 8; x++) {
  477.       setmask(x + width - 8, 8);
  478.       setmask(8, x);
  479.     }
  480.     for (y = 0; y < 7; y++)
  481.       setmask(8, y + width - 7);
  482.  
  483.     // timing row/col
  484.     for (x = 0; x < width - 14; x++)
  485.       if (x & 1) {
  486.         setmask(8 + x, 6);
  487.         setmask(6, 8 + x);
  488.       }
  489.       else {
  490.         qrframe[(8 + x) + width * 6] = 1;
  491.         qrframe[6 + width * (8 + x)] = 1;
  492.       }
  493.  
  494.     // version block
  495.     if (version > 6) {
  496.       t = vpat[version - 7];
  497.       k = 17;
  498.       for (x = 0; x < 6; x++)
  499.         for (y = 0; y < 3; y++ , k--)
  500.           if (1 & (k > 11 ? version >> (k - 12) : t >> k)) {
  501.             qrframe[(5 - x) + width * (2 - y + width - 11)] = 1;
  502.             qrframe[(2 - y + width - 11) + width * (5 - x)] = 1;
  503.           }
  504.           else {
  505.             setmask(5 - x, 2 - y + width - 11);
  506.             setmask(2 - y + width - 11, 5 - x);
  507.           }
  508.     }
  509.  
  510.     // sync mask bits - only set above for white spaces, so add in black bits
  511.     for (y = 0; y < width; y++)
  512.       for (x = 0; x <= y; x++)
  513.         if (qrframe[x + width * y])
  514.           setmask(x, y);
  515.  
  516.     // convert string to bitstream
  517.     // 8 bit data to QR-coded 8 bit data (numeric or alphanum, or kanji not supported)
  518.     v = strinbuf.length;
  519.  
  520.     // string to array
  521.     for (i = 0; i < v; i++)
  522.       eccbuf[i] = strinbuf.charCodeAt(i);
  523.     strinbuf = eccbuf.slice(0);
  524.  
  525.     // calculate max string length
  526.     x = datablkw * (neccblk1 + neccblk2) + neccblk2;
  527.     if (v >= x - 2) {
  528.       v = x - 2;
  529.       if (version > 9)
  530.         v--;
  531.     }
  532.  
  533.     // shift and repack to insert length prefix
  534.     i = v;
  535.     if (version > 9) {
  536.       strinbuf[i + 2] = 0;
  537.       strinbuf[i + 3] = 0;
  538.       while (i--) {
  539.         t = strinbuf[i];
  540.         strinbuf[i + 3] |= 255 & (t << 4);
  541.         strinbuf[i + 2] = t >> 4;
  542.       }
  543.       strinbuf[2] |= 255 & (v << 4);
  544.       strinbuf[1] = v >> 4;
  545.       strinbuf[0] = 0x40 | (v >> 12);
  546.     }
  547.     else {
  548.       strinbuf[i + 1] = 0;
  549.       strinbuf[i + 2] = 0;
  550.       while (i--) {
  551.         t = strinbuf[i];
  552.         strinbuf[i + 2] |= 255 & (t << 4);
  553.         strinbuf[i + 1] = t >> 4;
  554.       }
  555.       strinbuf[1] |= 255 & (v << 4);
  556.       strinbuf[0] = 0x40 | (v >> 4);
  557.     }
  558.     // fill to end with pad pattern
  559.     i = v + 3 - (version < 10);
  560.     while (i < x) {
  561.       strinbuf[i++] = 0xec;
  562.       // buffer has room    if (i == x)      break;
  563.       strinbuf[i++] = 0x11;
  564.     }
  565.  
  566.     // calculate and append ECC
  567.  
  568.     // calculate generator polynomial
  569.     genpoly[0] = 1;
  570.     for (i = 0; i < eccblkwid; i++) {
  571.       genpoly[i + 1] = 1;
  572.       for (j = i; j > 0; j--)
  573.         genpoly[j] = genpoly[j]
  574.           ? genpoly[j - 1] ^ gexp[modnn(glog[genpoly[j]] + i)] : genpoly[j - 1];
  575.       genpoly[0] = gexp[modnn(glog[genpoly[0]] + i)];
  576.     }
  577.     for (i = 0; i <= eccblkwid; i++)
  578.       genpoly[i] = glog[genpoly[i]]; // use logs for genpoly[] to save calc step
  579.  
  580.     // append ecc to data buffer
  581.     k = x;
  582.     y = 0;
  583.     for (i = 0; i < neccblk1; i++) {
  584.       appendrs(y, datablkw, k, eccblkwid);
  585.       y += datablkw;
  586.       k += eccblkwid;
  587.     }
  588.     for (i = 0; i < neccblk2; i++) {
  589.       appendrs(y, datablkw + 1, k, eccblkwid);
  590.       y += datablkw + 1;
  591.       k += eccblkwid;
  592.     }
  593.     // interleave blocks
  594.     y = 0;
  595.     for (i = 0; i < datablkw; i++) {
  596.       for (j = 0; j < neccblk1; j++)
  597.         eccbuf[y++] = strinbuf[i + j * datablkw];
  598.       for (j = 0; j < neccblk2; j++)
  599.         eccbuf[y++] = strinbuf[(neccblk1 * datablkw) + i + (j * (datablkw + 1))];
  600.     }
  601.     for (j = 0; j < neccblk2; j++)
  602.       eccbuf[y++] = strinbuf[(neccblk1 * datablkw) + i + (j * (datablkw + 1))];
  603.     for (i = 0; i < eccblkwid; i++)
  604.       for (j = 0; j < neccblk1 + neccblk2; j++)
  605.         eccbuf[y++] = strinbuf[x + i + j * eccblkwid];
  606.     strinbuf = eccbuf;
  607.  
  608.     // pack bits into frame avoiding masked area.
  609.     x = y = width - 1;
  610.     k = v = 1;         // up, minus
  611.     /* inteleaved data and ecc codes */
  612.     m = (datablkw + eccblkwid) * (neccblk1 + neccblk2) + neccblk2;
  613.     for (i = 0; i < m; i++) {
  614.       t = strinbuf[i];
  615.       for (j = 0; j < 8; j++ , t <<= 1) {
  616.         if (0x80 & t)
  617.           qrframe[x + width * y] = 1;
  618.         do {        // find next fill position
  619.           if (v)
  620.             x--;
  621.           else {
  622.             x++;
  623.             if (k) {
  624.               if (y != 0)
  625.                 y--;
  626.               else {
  627.                 x -= 2;
  628.                 k = !k;
  629.                 if (x == 6) {
  630.                   x--;
  631.                   y = 9;
  632.                 }
  633.               }
  634.             }
  635.             else {
  636.               if (y != width - 1)
  637.                 y++;
  638.               else {
  639.                 x -= 2;
  640.                 k = !k;
  641.                 if (x == 6) {
  642.                   x--;
  643.                   y -= 8;
  644.                 }
  645.               }
  646.             }
  647.           }
  648.           v = !v;
  649.         } while (ismasked(x, y));
  650.       }
  651.     }
  652.  
  653.     // save pre-mask copy of frame
  654.     strinbuf = qrframe.slice(0);
  655.     t = 0;           // best
  656.     y = 30000;         // demerit
  657.     // for instead of while since in original arduino code
  658.     // if an early mask was "good enough" it wouldn't try for a better one
  659.     // since they get more complex and take longer.
  660.     for (k = 0; k < 8; k++) {
  661.       applymask(k);      // returns black-white imbalance
  662.       x = badcheck();
  663.       if (x < y) { // current mask better than previous best?
  664.         y = x;
  665.         t = k;
  666.       }
  667.       if (t == 7)
  668.         break;       // don't increment i to a void redoing mask
  669.       qrframe = strinbuf.slice(0); // reset for next pass
  670.     }
  671.     if (t != k)         // redo best mask - none good enough, last wasn't t
  672.       applymask(t);
  674.     // add in final mask/ecclevel bytes
  675.     y = fmtword[t + ((ecclevel - 1) << 3)];
  676.     // low byte
  677.     for (k = 0; k < 8; k++ , y >>= 1)
  678.       if (y & 1) {
  679.         qrframe[(width - 1 - k) + width * 8] = 1;
  680.         if (k < 6)
  681.           qrframe[8 + width * k] = 1;
  682.         else
  683.           qrframe[8 + width * (k + 1)] = 1;
  684.       }
  685.     // high byte
  686.     for (k = 0; k < 7; k++ , y >>= 1)
  687.       if (y & 1) {
  688.         qrframe[8 + width * (width - 7 + k)] = 1;
  689.         if (k)
  690.           qrframe[(6 - k) + width * 8] = 1;
  691.         else
  692.           qrframe[7 + width * 8] = 1;
  693.       }
  695.     // return image
  696.     return qrframe;
  697.   }
  699.   var _canvas = null,
  700.     _size = null;
  702.   var api = {
  704.     get ecclevel() {
  705.       return ecclevel;
  706.     },
  708.     set ecclevel(val) {
  709.       ecclevel = val;
  710.     },
  712.     get size() {
  713.       return _size;
  714.     },
  716.     set size(val) {
  717.       _size = val
  718.     },
  720.     get canvas() {
  721.       return _canvas;
  722.     },
  724.     set canvas(el) {
  725.       _canvas = el;
  726.     },
  728.     getFrame: function (string) {
  729.       return genframe(string);
  730.     },
  732.     draw: function (string, canvas, size, ecc) {
  734.       ecclevel = ecc || ecclevel;
  735.       canvas = canvas || _canvas;
  737.       if (!canvas) {
  738.         console.warn('No canvas provided to draw QR code in!')
  739.         return;
  740.       }
  742.       size = size || _size || Math.min(canvas.width, canvas.height);
  744.       var frame = genframe(string),
  745.         ctx = canvas.ctx,
  746.         px = Math.round(size / (width + 8));
  748.       var roundedSize = px * (width + 8),
  749.         offset = Math.floor((size - roundedSize) / 2);
  751.       size = roundedSize;
  753.       ctx.clearRect(0, 0, canvas.width, canvas.height);
  754.       ctx.setFillStyle('#000000');
  755.       for (var i = 0; i < width; i++) {
  756.         for (var j = 0; j < width; j++) {
  757.           if (frame[j * width + i]) {
  758.             ctx.fillRect(px * (4 + i) + offset, px * (4 + j) + offset, px, px);
  759.           }
  760.         }
  761.       }
  762.       ctx.draw();
  763.     }
  764.   }
  766.   module.exports = {
  767.     api: api
  768.   }
  770. })()

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/905441
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。