├── README.md
└── qrCode.js


/README.md:
--------------------------------------------------------------------------------
 1 | #小程序生成二维码
 2 | 
 3 | ## 创建qrCode
 4 | > 本地新建一个qrCode.js,复制我的qrCode.js，保存
 5 | 
 6 | ## 引入qrCode
 7 | > 在需要生成的二维码页面的小程序js里面顶部引入`let qrCode=('../../utils/qrCode.js')`
 8 | `console.log(qrCode)` 如果可以直接输出一个`api`的对象即为引入成功
 9 | 
10 | ## 配置参数
11 | ### wxml
12 | > `<canvas style="width: 686rpx;height: 686rpx;background:#f1f1f1;" canvas-id="qrcCanvas"/>`
13 | 
14 | > `<input value='{{qrcStr}}'  bindblur="onQrcStrBlur" type="text" maxlength="255"   
15 |           />`
16 | ### js
17 | > 
18 | ```
19 | data:{
20 |     qrStr:'xxx'  需要生成字段
21 |     canvasId: "qrcCanvas",//需要绘画的元素
22 |  }
23 |  
24 |  //适配不同屏幕大小的canvas  
25 |    setCanvasSize(){  
26 |      var size={};  
27 |      try {  
28 |          var res = wx.getSystemInfoSync();  
29 |          var scale = 750/686;//不同屏幕下canvas的适配比例；设计稿是750宽  
30 |          var width = res.windowWidth/scale;  
31 |          var height = width;//canvas画布为正方形  
32 |          size.w = width;  
33 |          size.h = height;  
34 |        } catch (e) {  
35 |          // Do something when catch error  
36 |          console.log("获取设备信息失败"+e);  
37 |        }   
38 |      return size;  //返回大小
39 |    } ,  
40 |    
41 |    createQrCode(str,canvasId,cavW,cavH){  
42 |        //调用插件中的draw方法，绘制二维码图片  
43 |        qrCode.api.draw(str,canvasId,cavW,cavH);  
44 |      
45 |     },  
46 |      
47 |    //获取input输入的值  
48 |    onQrcStrBlur(e) {  
49 |        this.setData({qrcStr: e.detail.value});  
50 |    },  
51 |      
52 |    //在  onReady调用
53 |    onReady: function() {  
54 |        let size = this.setCanvasSize();//动态设置画布大小  
55 |        this.createQrCode(this.data.qrcStr, this.canvasId, size.w, size.h);  
56 |     },    
57 |  ```
58 |  
59 | 


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


--------------------------------------------------------------------------------