• 微信小程序之生成二维码

    qrcode库

    1. var QR = (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);
    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.     }
    698.     var _canvas = null;
    700.     var api = {
    702.         get ecclevel() {
    703.             return ecclevel;
    704.         },
    706.         set ecclevel(val) {
    707.             ecclevel = val;
    708.         },
    710.         get size() {
    711.             return _size;
    712.         },
    714.         set size(val) {
    715.             _size = val
    716.         },
    718.         get canvas() {
    719.             return _canvas;
    720.         },
    722.         set canvas(el) {
    723.             _canvas = el;
    724.         },
    726.         getFrame: function (string) {
    727.             return genframe(string);
    728.         },
    729.         //这里的utf16to8(str)是对Text中的字符串进行转码，让其支持中文
    730.         utf16to8: function (str) {
    731.             var out, i, len, c;
    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.         },
    751.         draw: function (str, canvas, cavW, cavH, ecc) {
    753.             ecclevel = ecc || ecclevel;
    754.             canvas = canvas || _canvas;
    755.             if (!canvas) {
    756.                 console.warn('No canvas provided to draw QR code in!')
    757.                 return;
    758.             }
    760.             var size = Math.min(cavW, cavH);
    761.             str = this.utf16to8(str);//增加中文显示
    762.             console.log(str)
    763.             var tk = 6;
    764.             //
    765.             var frame = this.getFrame(str),
    766.                 ctx = wx.createCanvasContext(canvas),
    767.                 px = Math.round(size / (width + (tk * 2)));
    768.             var roundedSize = px * (width + (tk * 2)),
    769.                 offset = Math.floor((size - roundedSize) / 2);
    770.             size = roundedSize;
    771.             //var cx = offset;
    772.             //offset = 0;
    773.             // cavW = cavW + cx;
    774.             //cavH = cavH + cx;
    776.             ctx.clearRect(0, 0, cavW, cavW);
    777.             ctx.setFillStyle('#000000');
    778.             for (var i = 0; i < width; i++) {
    779.                 for (var j = 0; j < width; j++) {
    780.                     if (frame[j * width + i]) {
    781.                         ctx.fillRect(px * (tk + i) + offset, px * (tk + j) + offset, px, px);
    782.                     }
    783.                 }
    784.             }
    785.             // ctx.drawImage("https://cmmerchant.oss-cn-qingdao.aliyuncs.com/microapp/czlogo.png", cavW / 2 - (cavW / 6)/2, cavH / 2 - (cavH / 6)/2,cavW/6,cavH/6);
    786.             ctx.draw();
    787.         }
    788.     }
    789.     module.exports = {
    790.         qrApi: api
    791.     }
    793. })();

    页面代码

    1.     <view class="qrcode_img_main">
    2.         <canvas id="qrcode" canvas-id="qrcode" style="z-index:1;width:{{width}}rpx;height:{{height}}rpx;" />
    3.     </view>

     JS

    1. var QR = require("../../../../utils/qrcode");
    2. Page({
    3.   data: {
    4.     width: 512,
    5.     height: 512
    6.   },
    7.  
    8.   onLoad(options) {
    9.     this.getURL()
    10.   },
    11.   getURL() {
    12.     var size = this.setCanvasSize();
    13.     QR.qrApi.draw('图片地址' "qrcode", size.w, size.h);
    14.   },
    15.   // 计算二维码宽高
    16.   setCanvasSize: function () {
    17.     var that = this;
    18.     var size = {};
    19.     try {
    20.       var res = wx.getSystemInfoSync();
    21.       var scale = 750 / res.windowWidth;//不同屏幕下canvas的适配比例；设计稿是750宽
    22.       var width = that.data.width / scale;
    23.       var height = width;//canvas画布为正方形
    24.       size.w = width;
    25.       size.h = height;
    26.     } catch (e) {
    27.       console.log("获取设备信息失败" + e);
    28.     }
    29.     return size;
    30.   },
    31.  
    32.  
    33. })

    微信画布绘制海报

     var context = wx.createCanvasContext('mycanvas'); // 获取画布

    CanvasContext.fillText

    • string text 在画布上输出的文本
    • number x 绘制文本的左上角 x 坐标位置
    • number y 绘制文本的左上角 y 坐标位置
    • number maxWidth 需要绘制的最大宽度，可选

    CanvasContext.drawImage

    • string imageResource 所要绘制的图片资源（网络图片要通过  downloadFile 先下载
    • number sx 需要绘制到画布中的，imageResource的矩形（裁剪）选择框的左上角 x 坐标
    • number sy 需要绘制到画布中的，imageResource的矩形（裁剪）选择框的左上角 y 坐标
    • number sWidth 需要绘制到画布中的，imageResource的矩形（裁剪）选择框的宽度
    • number sHeight 需要绘制到画布中的，imageResource的矩形（裁剪）选择框的高度
    • number dx imageResource的左上角在目标 canvas 上 x 轴的位置
    • number dy imageResource的左上角在目标 canvas 上 y 轴的位置
    • number dWidth 在目标画布上绘制 imageResource 的宽度，允许对绘制的 imageResource 进行缩放
    • number dHeight 在目标画布上绘制 imageResource 的高度，允许对绘制的 imageResource 进行缩放
    1. var context = wx.createCanvasContext('mycanvas');
    2. context.drawImage('xxx', 0, 0, 375, 522)
    3. downloadFile(url) {
    4.     return new Promise(function (resolve, reject) {
    5.       wx.downloadFile({
    6.         url,
    7.         success: function (res) {
    8.           if (res.statusCode === 200) {
    9.             resolve(res.tempFilePath)
    10.           }
    11.         },
    12.         fail: function (res) {
    13.           reject(res)
    14.         }
    15.       });
    16.     });
    17.   },
    • CanvasContext.fillText(string text, number x, number y, number maxWidth) 在画布上绘制被填充的文本
    • CanvasContext.setFontSize(number fontSize) 设置字体的字号
    • CanvasContext.setTextAlign(string align) 设置文字的对齐
    • CanvasContext.stroke() 画出当前路径的边框。默认颜色色为黑色。
    • CanvasContext.draw();   绘制完成

    wx.canvasToTempFilePath(Object object, Object this)​​​​​​​

    把当前画布指定区域的内容导出生成指定大小的图片。在 draw() 回调里调用该方法才能保证图片导出成功。

     

    1.     //将生成好的图片保存到本地，需要延迟一会，绘制期间耗时
    2.     setTimeout(function () {
    3.       wx.canvasToTempFilePath({
    4.         canvasId: 'mycanvas',
    5.         success: function (res) {
    6.           var tempFilePath = res.tempFilePath;
    7.           that.setData({
    8.             imagePath: tempFilePath,
    9.             canvasHidden: true
    10.           });
    11.         },
    12.         fail: function (res) {
    13.           console.log(res);
    14.         }
    15.       });
    16.     }, 200);

  • 相关阅读:
    为什么说使用领英的人一定要用领英精灵
    Shell 脚本面试指南
    面试八股文：C++ 多态 继承 重载 虚函数
    Android Studio 常见问题
    C++的缺省参数、函数重载和引用
    含碘稀土铕(Ⅲ)配合物荧光微球/稀土铕配合物掺杂功能化二氧化硅微球的制备方法
    【力扣每日一题】2023.9.3 消灭怪物的最大数量
    SpringBoot自动装配
    Session会话追踪的实现机制
    J3D在UOS+KIRIN崩溃2：深层原因分析
  • 原文地址：https://blog.csdn.net/qq_63358859/article/details/127803110