File size: 80,213 Bytes
6f28f9e 2a2a176 6f28f9e a59c3c4 6f28f9e 2a2a176 6f28f9e 378f397 2a2a176 6f28f9e 378f397 6f28f9e 2a2a176 6f28f9e 378f397 6f28f9e 378f397 6f28f9e 378f397 6f28f9e d1f47f9 6f28f9e d1f47f9 6f28f9e d1f47f9 6f28f9e 378f397 6f28f9e a59c3c4 6f28f9e a59c3c4 6f28f9e a59c3c4 6f28f9e a59c3c4 6f28f9e d1f47f9 378f397 6f28f9e d1f47f9 6f28f9e d1f47f9 6f28f9e d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 a59c3c4 d1f47f9 378f397 d1f47f9 ca6e756 a59c3c4 ca6e756 a59c3c4 ca6e756 de7cd1e ca6e756 5b3cd1e 378f397 5b3cd1e 811f3a9 5b3cd1e 811f3a9 5b3cd1e 811f3a9 5b3cd1e 378f397 5b3cd1e 811f3a9 5b3cd1e 6f28f9e d1f47f9 6f28f9e 2a2a176 378f397 2a2a176 6f28f9e 2a2a176 a59c3c4 378f397 6f28f9e 378f397 6f28f9e 378f397 6f28f9e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 | {
"levels": {
"easy": {
"name": "Easy",
"gist": "Phones’ own scanners read codes like this, and Android Settings’ scanner reads nearly all of them too.",
"line": "Of the {n} measured codes all eight scanners place at this level, {mix}, all three phones’ own scanners read {all3} at 1280 pixels, and Android Settings’ {zxing}.",
"line_yours": "Of the measured codes in {class}, like yours, the five scanners here place {n} at this level: {mix}. All three phones’ own scanners read {all3} of those {frame}, and Android Settings’ {zxing}."
},
"everyday": {
"name": "Everyday",
"gist": "Phones’ own scanners read codes like this; Android Settings’ scanner misses some, and most in pictures up to 1280 pixels.",
"line": "Of the {n} measured codes all eight scanners place at this level, {mix}, all three phones’ own scanners read {all3} at 1280 pixels, and Android Settings’ {zxing}.",
"line_yours": "Of the measured codes in {class}, like yours, the five scanners here place {n} at this level: {mix}. All three phones’ own scanners read {all3} of those {frame}, and Android Settings’ {zxing}."
},
"tough": {
"name": "Tough",
"gist": "Phones’ own scanners read most codes like this; Android Settings’ scanner misses many, and nine in ten in pictures up to 1280 pixels.",
"line": "Of the {n} measured codes all eight scanners place at this level, {mix}, each phone’s own scanner read {each3} at 1280 pixels, all three together {all3}, and Android Settings’ {zxing}.",
"line_yours": "Of the measured codes in {class}, like yours, the five scanners here place {n} at this level: {mix}. Each phone’s own scanner read {each3} of those {frame}, all three together {all3}, and Android Settings’ {zxing}."
},
"advanced": {
"name": "Advanced",
"gist": "Phones’ own scanners often miss codes like this, and Android Settings’ scanner almost never reads them.",
"line": "Of the {n} measured codes all eight scanners place at this level, {mix}, each phone’s own scanner read {each3} at 1280 pixels, at least one of them {any3}, and Android Settings’ {zxing}.",
"line_yours": "Of the measured codes in {class}, like yours, the five scanners here place {n} at this level: {mix}. Each phone’s own scanner read {each3} of those {frame}, at least one of them {any3}, and Android Settings’ {zxing}.",
"line_pile_hi": "Of the {n} measured codes none of the five read at any size, like yours: {mix}. Each phone’s own scanner read {each3} of those at 1280 pixels, and at least one of them {any3}."
},
"class": {
"big": "pictures over 1280 pixels on the long side",
"small": "pictures up to 1280 pixels on the long side"
},
"frame": {
"big": "at 1280 pixels",
"small": "at their own size"
},
"mix": {
"prints": "simulated prints",
"photos": "real photos",
"research": "research images",
"mostly": "mostly {parts}"
},
"advanced_pile_hi": "Advanced, if it holds a code",
"phones_defined": "Phones’ own scanners: Apple’s, Google’s and Huawei’s. Android Settings’ scanner: the one Android’s Settings app uses for Wi-Fi codes.",
"relation": "On the curve, the levels line up with the simulated prints: most clean prints are Easy ({clean_easy} of {clean_n}), most everyday prints Everyday ({everyday_everyday} of {everyday_n}), and most tough prints Tough ({tough_tough} of {tough_n}). Advanced lies beyond them, with the pile on the right.",
"row_prefix": "{level}, confidence {grade}.",
"row_prefix_pile_hi": "{level} if it holds a code, confidence {grade}.",
"row_prefix_plain": "{level}.",
"bell_band_aria": "Levels along the scale, from easy to hard: {names}.",
"readout_prefix": "{level}.",
"more_summary": "What the four levels mean",
"band": {
"below": "below {c}",
"between": "{a} to {b}",
"above": "{c} and up"
}
},
"confidence": {
"phrase": "Confidence: {grade}",
"grade": {
"high": "high",
"medium": "medium",
"low": "low"
},
"why": {
"pile_lo": "All five read it at every size.",
"pile_hi": "None of the five read a code in it at any size, and for codes like that, the five nearly always give the level all eight do.",
"few_reads": "Only one of the five read it {frame}.",
"few_reads_none": "None of the five read it {frame}; some did at another size.",
"near_cut": "It sits near the boundary between {level} and {other}.",
"partial": "Some reads didn’t finish in time and count as misses, so it may be easier than this.",
"clear": "{count} of the five read it {frame}, and for codes read like that, the five nearly always give the level all eight do.",
"clear_all": "All five read it {frame}, and for codes read like that, the five nearly always give the level all eight do."
},
"frame": {
"big": "at 1280 pixels",
"small": "at its own {long} pixels"
},
"agreement_pct": "Of the {n} measured codes read like this, {pct} got the same level from all eight scanners.",
"agreement_pct_short": "{pct} of the measured codes read like this got the same level from all eight scanners.",
"agreement_all": "All {n} measured codes read like this got the same level from all eight scanners.",
"agreement_pile_hi": "Of the {n} measured codes like this, all holding a code, {pct} got the same level from all eight scanners.",
"partial_note": "A reading cut short is always low. Try it again from your list.",
"not_run_all": "OpenCV’s newer detector wasn’t run on this picture: it slows sharply as the codes in a picture multiply, so its reads count as misses, and it may be a little easier than this. Its confidence is at most medium.",
"not_run_from": "OpenCV’s newer detector wasn’t run from {px} pixels down: it slows sharply as the codes in a picture multiply, so those reads count as misses, and it may be a little easier than this. Its confidence is at most medium.",
"phrase_section": "Confidence: {grade}."
},
"verdict": {
"score": "Difficulty {s} of 100",
"score_lo": "Off the easy end of the scale",
"score_hi": "Off the hard end of the scale, if it holds a code",
"to_checks": "Why, and what to do",
"to_try": "What to try"
},
"panel": {
"picture_label": "Picture {n}:",
"measured_heading": "A measured code from this spot",
"measured_level": "Difficulty {s} of 100",
"measured_level_lo": "Off the easy end of the scale",
"measured_level_hi": "Off the hard end of the scale",
"next": "Another code from here",
"measured_alt": "A measured QR code from this spot: {source}",
"open": "Open the full picture, and try it with your phone ↗",
"count": {
"all": "Read by all {eight} scanners",
"none": "Read by none of the {eight}",
"some": "Read by {n} of the {all} scanners"
},
"scanner": {
"apple": "Apple’s: {result}",
"google": "Google’s: {result}",
"huawei": "Huawei’s: {result}",
"others": "the other five: {n} of {all}"
},
"result": {
"read": "read",
"missed": "missed"
},
"source": {
"pristine": "Clean print, simulated for this test",
"everyday": "Everyday print, simulated for this test",
"tough": "Tough print, simulated for this test",
"boofcv": "Real photo, BoofCV research set",
"qrdn": {
"clean": "Clean code, QR-DN1.0 research set",
"distorted": "Distorted, noisy code, QR-DN1.0 research set"
},
"syn10k": "Computer-made warped code, syn10k research set",
"broken104": "Real code that fails, collected from the web"
},
"yours_alt": "Your picture {n}, {name}",
"back": "A measured code from here"
},
"bell": {
"lede": "All {N} codes measured at seven sizes, on one scale from easy to hard, shaded by how many of {eight} scanners read each one. Your pictures appear on it as numbered lines.",
"caption_levels": "The four levels under the scale come from the difficulty alone.",
"key_title": "How many of the {eight} scanners read each code:",
"zone": {
"all": {
"name": "All {eight}",
"words": "all {eight}"
},
"most": {
"name": "Most",
"words": "most ({lo} to {hi})"
},
"some": {
"name": "Some",
"words": "some ({lo} to {hi})"
},
"none": {
"name": "None",
"words": "none"
}
},
"pile": {
"mix": "{mix_share} of the mix",
"lo": "Read by every scanner at every resolution",
"hi": "Read by no scanner at any resolution"
},
"aria": "QR codes from easiest to hardest, shaded by how many of the {eight} scanners read each one: all {eight}, most, some or none.",
"aria_one": "Your picture is a numbered line on it.",
"aria_many": "Your {n} pictures are numbered lines on it.",
"readout": {
"pile_lo": "Codes here were read by every scanner at every image resolution.",
"pile_hi": "Codes here were read by no scanner at any image resolution.",
"curve": "The curve here: {shares}.",
"part_first": "{pct} read by {zone}",
"part": "{pct} by {zone}"
}
},
"yours": {
"empty_title": "Your picture",
"empty": "Choose one of your pictures in the list under the curve to see how wide to print it, how hard it is to scan, and why.",
"title": "Why it’s {level}",
"back": "Back to the picture in your list",
"five": {
"pile_lo": "All five read it, at every size.",
"pile_hi": "None of the five read a code in it, at any size.",
"all": "All five read it.",
"none_1280": "None of the five read it at 1280 pixels; some did at another size.",
"most": "{count} of the five read it; {names} missed it.",
"some": "{count} of the five read it: {names}."
}
},
"view": {
"caption": "Roughly as the scanners saw it at 1280 pixels, in grey and enlarged. The line round the code runs 4 squares out, the margin the QR standard asks for.",
"aria": "The code in picture {n}, roughly as the scanners saw it, with a line round it 4 squares out",
"caption_small": "Roughly as the scanners saw it, at its own {long} pixels, in grey and enlarged. The line round the code runs 4 squares out, the margin the QR standard asks for.",
"caption_plain": "Roughly as the scanners saw it at 1280 pixels, in grey. The line round the code runs 4 squares out, the margin the QR standard asks for.",
"caption_small_plain": "Roughly as the scanners saw it, at its own {long} pixels, in grey. The line round the code runs 4 squares out, the margin the QR standard asks for.",
"caption_edge": "Stripes show where the picture ends."
},
"phone": {
"summary": "What a phone sees",
"caption": "Printed {w} wide and seen from {d} away, this code gets about {px} of the {frame} pixels across a phone camera’s picture: about {p} for each square.",
"caption_each": "Printed {w} wide and seen from {d} away, each code gets about {px} of the {frame} pixels across a phone camera’s picture: about {p} for each square.",
"caption_screen": "Shown {w} wide on a screen and seen from {d} away, this code gets about {px} of the {frame} pixels across a phone camera’s picture: about {p} for each square.",
"caption_screen_each": "Shown {w} wide on a screen and seen from {d} away, each code gets about {px} of the {frame} pixels across a phone camera’s picture: about {p} for each square.",
"drawn": "They’re drawn here in grey, as scanners read them, and enlarged.",
"drawn_plain": "They’re drawn here in grey, as scanners read them.",
"note": "An illustration, not a scan: it leaves out the tilt, blur, shake, lower contrast and uneven light of a quick everyday scan, which the answer allows for, and it assumes the camera described under “How this is worked out”, untested on real phones.",
"aria": "The code in picture {n} as a phone’s scanner would get it, in grey",
"cant": "This picture can’t be drawn in this browser as it was read."
},
"status": {
"ok": {
"word": "Fine",
"legend": "Fine: in the factor tests, all eight scanners read 9 in 10 test codes like this."
},
"watch": {
"word": "Borderline",
"legend": "Borderline: the phones’ own scanners read 9 in 10 such test codes, but at least one other scanner didn’t."
},
"problem": {
"word": "Problem",
"legend": "Problem: at least one phone’s own scanner read fewer than 9 in 10 such test codes."
},
"margin_legend": "The margin follows the QR standard instead: Fine from the 4 squares it asks for, Borderline below that, and a Problem with next to none, under a quarter square. In the margin test, all eight scanners still read 9 in 10 test codes with half a square."
},
"checks": {
"heading": "Checks on the picture",
"sub": "The checks point to what may make a code hard to scan. They never change its level or its confidence.",
"caption": "Checks on picture {n}",
"col": {
"check": "Check",
"status": "Status",
"measured": "Measured",
"advice": "Why, and what to do"
},
"summary": {
"list": "{word}: {names}.",
"together": "Each is only Borderline, but together they can make a code {level}.",
"unmeasured": "One Borderline check may not be all that makes it {level}: something the checks don’t measure may add to it, such as smudges, round dots or a curved surface."
},
"none": "None of the checks stands out.",
"none_partial": "Nothing stands out among the checks that could be measured.",
"none_hard": "None of the checks stands out, so what makes it {level} may be something they don’t measure, such as smudges, a covered corner square, round dots, a logo or a curved surface.",
"unavailable": "No scanner here found the code, so the checks can’t measure it.",
"not_measured": "Not measured",
"failed": "The checks couldn’t measure this picture.",
"skipped_partial": "The checks run only on a reading that finishes.",
"more_summary": "How the checks are measured",
"footer": "Limits from QR Scan Difficulty’s factor tests: one code all eight scanners read, changed one thing at a time, 80 test codes a step, read at 1280 pixels. Each limit sits halfway between the check’s typical values on the last step with one status and the first step with the next; where two tests set one limit, it sits in the middle of the range both allow. Pixels per square takes its limits from the tests the widths come from instead, in good light, as the factor tests start: 80 test codes a step from 1.6 to 6 camera pixels per square, at versions 2 to 21. Its Problem limit rises with the version, and a version between two tested ones takes the next one’s, as the widths do.",
"ppm": {
"name": "Pixels per square",
"what": "How many camera pixels fall across each small square of the code, with the picture at 1280 pixels on its long side, or at its own size if smaller, leaving aside any tilt, which the angle check covers. Each square needs a few to stand apart from its neighbours.",
"value": "{ppm} camera pixels per square at 1280 pixels",
"value_small": "{ppm} camera pixels per square, at the picture’s own {long} pixels",
"value_graphic": "{ppm_native} pixels per square in the file, {ppm} at 1280 pixels",
"value_graphic_small": "{ppm_native} pixels per square in the file",
"explain": {
"small": {
"watch": "In good light, enough for the phones’ own scanners, which read 9 in 10 test codes down to 2 camera pixels per square, but not for all eight: Android Settings’ scanner read 9 in 10 only from 4, and OpenCV’s original detector from 5.",
"watch_mid": "In good light, enough for the phones’ own scanners, which read 9 in 10 version 6 and 8 test codes down to 2.3 camera pixels per square, but not for all eight: at 4, Android Settings’ scanner read 71 of 80 version 8 ones, and OpenCV’s original detector 60. Codes with more squares need more pixels each.",
"watch_big": "In good light, enough for the phones’ own scanners, which read 9 in 10 version 10 and 13 test codes down to 2.6 camera pixels per square, and version 21 ones down to 3.5, but not for all eight: at 4, Android Settings’ scanner read 70 of 80 version 10 ones, and OpenCV’s original detector 59. Codes with more squares need more pixels each.",
"problem": "Too few, even in good light: below about 2 camera pixels per square, the phones’ own scanners start to miss. At 1.8, Apple’s read 62 of 80 version 2 test codes.",
"problem_mid": "Too few, even in good light: below about 2 camera pixels per square, the phones’ own scanners start to miss, and codes with more squares need more: at 2, Apple’s read 64 of 80 version 8 test codes.",
"problem_big": "Too few for a code with this many squares, even in good light: at 2.3 camera pixels per square, Google’s scanner read 51 of 80 version 13 test codes, and at 3, 64 of 80 version 21 ones."
}
},
"advice": {
"small": {
"watch": {
"unsure": "Make the code bigger in the picture: print or show it bigger, or bring the phone closer. About {grow_ok} times as wide gives {ok_ppm} camera pixels per square, which every scanner in the tests read in good light.",
"graphic": "That counts the file shrunk to 1280 pixels, not a print of it: how wide it’s printed sets how many camera pixels each square gets where people scan.",
"graphic_small": "The file has few pixels per square, and copies inherit them: export it again about {grow_ok} times as big, each square a whole number of pixels, rather than enlarging this one.",
"print": "From where this photo was taken, print it about {grow_ok} times as wide, or invite people closer: twice the size gives twice the camera pixels per square.",
"screen": "Show it about {grow_ok} times as big, by zooming in or giving it more of the screen, or bring the phone closer."
},
"problem": {
"unsure": "Make the code at least {grow_watch} times as big in the picture, or {grow_ok} times for every scanner in the tests in good light: print or show it bigger, or bring the phone closer.",
"graphic": "That counts the file shrunk to 1280 pixels, not a print of it: how wide it’s printed sets how many camera pixels each square gets where people scan, and a small code in a big design needs a big print.",
"graphic_small": "The file has too few pixels per square, and copies inherit them: export it again at least {grow_watch} times as big, or {grow_ok} times for every scanner in the tests in good light, each square a whole number of pixels.",
"print": "From where this photo was taken, print it at least {grow_watch} times as wide, or {grow_ok} times for every scanner in the tests in good light, or invite people much closer.",
"screen": "Show it at least {grow_watch} times as big, by zooming in or giving it more of the screen, or bring the phone much closer."
}
}
}
},
"size": {
"name": "Size",
"what": "How many squares the code has across, which grows with the amount of data, and how much of the picture it fills. At the same printed size, more squares means smaller squares.",
"value": "Version {version}: {squares} × {squares} squares, {px} pixels wide in the picture, {share} of its long side",
"value_estimate": "About version {version}: {squares} × {squares} squares, {px} pixels wide in the picture, {share} of its long side",
"value_unknown": "{px} pixels wide in the picture, {share} of its long side",
"note": {
"tight": {
"unsure": "The code fills more of this picture than in any simulated print. Close up or cropped tight, each square gets more camera pixels than in a photo taken from where people will scan it, so this picture can land at an easier level than that photo.",
"graphic": "That’s normal for a file: the code fills much of it. How wide to print it comes from that share; a photo of the print, from where people will stand, shows how hard the code is to read there.",
"print": "This photo is a close-up or a tight crop. If people will scan the print from further away, each square gets fewer camera pixels there, and a photo from there can land at a harder level: add one to compare.",
"screen": "This photo is a close-up or a tight crop. If people will hold their phones further from the screen, each square gets fewer camera pixels, and a photo from there can land at a harder level: add one to compare."
},
"small": {
"unsure": "The scanners read this picture at its own {long} pixels on the long side, never enlarged. If it’s a smaller copy, as messaging apps often send, add the full-size original: it can land at an easier level.",
"graphic": "",
"print": "The scanners read this photo at its own {long} pixels on the long side, never enlarged. If it’s a smaller copy, as messaging apps often send, add the full-size original: it can land at an easier level.",
"screen": "The scanners read this photo at its own {long} pixels on the long side, never enlarged. If it’s a smaller copy, as messaging apps often send, add the full-size original: it can land at an easier level."
},
"svg": "An SVG has no pixel size of its own: this one was drawn at {long} pixels on its long side, the largest size pictures are read at, so its pixel figures are for that drawing."
},
"explain": {
"dense": {
"watch": "With 6 camera pixels per square, the phones’ own scanners read 9 in 10 test codes up to version 21 (101 squares across), but Android Settings’ read 70 of 80 at version 15 and 57 at version 21.",
"beyond": "The tests stop at version 21 (101 squares across). A code with more squares needs a bigger print still to give each square enough camera pixels."
}
},
"advice": {
"dense": {
"watch": {
"unsure": "Shorten the content, such as with a shorter link, so the code needs fewer squares, or make it bigger.",
"graphic": "Shorten the content, such as with a shorter link, so the code needs fewer squares, or plan to print or show it big.",
"print": "Print it bigger as the data grows, or shorten the content. At GS1’s target of 0.495 mm a square for packaging, this code is {mm_margin} wide with its margin.",
"screen": "Show it bigger, or shorten the content so the code needs fewer squares."
}
}
}
},
"quiet": {
"name": "Margin",
"what": "The plain border round the code. Scanners find a code by its three corner squares, and marks close beside it can confuse them. The QR standard asks for 4 squares.",
"value": "{margin} clear on its narrowest side",
"value_full": "4 squares or more clear all round",
"value_none": "Next to no clear margin on its narrowest side",
"value_cut": "The picture ends {margin} from the code",
"value_cut_none": "The picture ends at the code",
"value_under": "Less than {margin} clear on its narrowest side",
"value_unpinned": "The corner squares didn’t show exactly where the code’s edges are",
"margin_one": "{amount} square",
"margin_many": "{amount} squares",
"explain": {
"margin": {
"watch": "By the QR standard, not the tests: less than the 4 squares it asks for, and marks inside that border can make a code harder to read. In the margin test, all eight scanners still read 9 in 10 test codes with half a square.",
"watch_under": "By the QR standard, not the tests: less than the 4 squares it asks for, and with squares this small or soft the check can’t tell how much less: there may be next to none. With clutter right beside the code, Google’s scanner read 7 of 80 test codes.",
"problem": "Next to no margin. With clutter right beside the code, Google’s scanner read 7 of 80 test codes and Android Settings’ none; Apple’s and Huawei’s read all 80."
},
"edge": {
"watch": "The picture is cropped close, so the margin can’t be seen beyond its edge.",
"problem": "The picture ends at the code, so there is no margin to see."
}
},
"advice": {
"margin": {
"watch": {
"unsure": "Leave 4 squares of plain, light space round the code on every side.",
"graphic": "Add the margin in the file itself, 4 squares of white on every side, so it goes wherever the code goes.",
"print": "Keep text, pictures and the edge of the label at least 4 squares from the code on every side.",
"screen": "Keep buttons, text and the edge of the screen at least 4 squares from the code."
},
"problem": {
"unsure": "Clear 4 squares of plain, light space round the code on every side.",
"graphic": "Add the margin in the file itself, 4 squares of white on every side, so it goes wherever the code goes.",
"print": "Move text, pictures and the edge of the label at least 4 squares away from the code on every side.",
"screen": "Move buttons, text and the edge of the screen at least 4 squares away from the code."
}
},
"edge": {
"watch": {
"unsure": "Crop less tightly: leave room round the code when you take or crop the picture.",
"graphic": "The file ends {margin} from the code: add white round it, 4 squares on every side, so the margin goes wherever the code goes.",
"print": "Crop less tightly: leave room round the code when you take or crop the photo.",
"screen": "Crop less tightly: leave room round the code when you take or crop the photo."
},
"problem": {
"unsure": "Crop less tightly: leave room round the code when you take or crop the picture.",
"graphic": "The file ends at the code: add white round it, 4 squares on every side, so the margin goes wherever the code goes.",
"print": "Crop less tightly: leave room round the code when you take or crop the photo.",
"screen": "Crop less tightly: leave room round the code when you take or crop the photo."
}
}
}
},
"blur": {
"name": "Sharpness",
"what": "How far the edges are smeared, compared with the size of a square. Blur, from focus or a moving hand, spreads each square into its neighbours.",
"value": "Blur about {blur_pct} of a square",
"explain": {
"blur": {
"watch": "The phones’ own scanners read 9 in 10 test codes with blur up to 38% of a square, and Google’s 49 of 80 at 44%; Android Settings’ only up to 25%.",
"problem": "Past where phones start to miss: at half a square of blur, Google’s scanner read 18 of 80 test codes, and at 62%, only Huawei’s read any (8)."
},
"small": {
"watch": "The blur is under a camera pixel, about what an in-focus picture shows, but the squares are so small that it still covers {blur_pct} of each. In the focus test, Android Settings’ scanner read 9 in 10 test codes only up to a quarter of a square.",
"problem": "The blur is under a camera pixel, about what an in-focus picture shows, but the squares are so small that it still covers {blur_pct} of each. At half a square of blur, Google’s scanner read 18 of 80 test codes."
}
},
"advice": {
"blur": {
"watch": {
"unsure": "Take it again, holding still once the camera has focused. If every photo is this soft, make the code bigger.",
"graphic": "The file itself is soft: make it again at its final size, with crisp edges and each square a whole number of pixels, rather than enlarging a small copy.",
"print": "Let the camera focus and hold still. If photos from the usual distance are always soft, print the code bigger, so blur covers less of each square.",
"screen": "Let the camera focus on the screen and hold still. If it can’t focus that close, move back and show the code bigger."
},
"problem": {
"unsure": "Take it again, holding still once the camera has focused. If every photo is this soft, make the code bigger.",
"graphic": "The file itself is soft: make it again at its final size, with crisp edges and each square a whole number of pixels, rather than enlarging a small copy.",
"print": "Let the camera focus and hold still. If photos from the usual distance are always soft, print the code bigger, so blur covers less of each square.",
"screen": "Let the camera focus on the screen and hold still. If it can’t focus that close, move back and show the code bigger."
}
},
"small": {
"watch": {
"unsure": "Make the code bigger in the picture, by printing or showing it bigger or bringing the phone closer, so the same blur covers less of each square.",
"graphic": "Export it with more pixels per square, each square a whole number of pixels with crisp edges, rather than enlarging a small copy.",
"print": "Print it bigger, or invite people closer, so the camera’s own blur covers less of each square.",
"screen": "Show it bigger, by zooming in or giving it more of the screen, so the camera’s own blur covers less of each square."
},
"problem": {
"unsure": "Make the code much bigger in the picture, by printing or showing it bigger or bringing the phone closer, so the same blur covers less of each square.",
"graphic": "Export it with many more pixels per square, each square a whole number of pixels with crisp edges, rather than enlarging a small copy.",
"print": "Print it much bigger, or invite people much closer, so the camera’s own blur covers less of each square.",
"screen": "Show it much bigger, by zooming in or giving it more of the screen, so the camera’s own blur covers less of each square."
}
}
}
},
"contrast": {
"name": "Contrast",
"what": "How much darker the dark squares are than the light ones, as a share of the step from white to black. With little difference, noise and uneven light push squares to the wrong side.",
"value": "{contrast_pct} contrast",
"value_inverted": "{contrast_pct} contrast, light squares on dark",
"explain": {
"contrast": {
"watch": "The phones’ own scanners read 9 in 10 test codes down to 11%, and Google’s 40 of 80 at 8%; Android Settings’ needs 31%.",
"problem": "Too faint: at 8%, Google’s scanner read 40 of 80 test codes, and at 6%, none."
},
"inverted": {
"watch": "Light squares on a dark background: the phones’ own scanners read 79 to 80 of 80 such test codes, but OpenCV’s two detectors read none.",
"problem": "Light squares on a dark background: the phones’ own scanners read 79 to 80 of 80 such test codes, but OpenCV’s two detectors read none."
}
},
"advice": {
"contrast": {
"watch": {
"unsure": "Make the dark squares darker or the light ones lighter. Black on white works best.",
"graphic": "Use very dark squares on a very light background, ideally black on white, with no gradient behind the code.",
"print": "Print very dark ink on a light, matte background. Black on white works best.",
"screen": "Turn the screen’s brightness up, and show the code dark on light."
},
"problem": {
"unsure": "Make the dark squares much darker or the light ones much lighter. Black on white works best.",
"graphic": "Use very dark squares on a very light background, ideally black on white, with no gradient behind the code.",
"print": "Print very dark ink on a light, matte background. Black on white works best.",
"screen": "Turn the screen’s brightness up, and show the code dark on light."
}
},
"inverted": {
"watch": {
"unsure": "If you can, make it dark on light: some scanners never look for light-on-dark codes.",
"graphic": "If you can, make it dark on light: some scanners never look for light-on-dark codes.",
"print": "If you can, print it dark on light: some scanners never look for light-on-dark codes.",
"screen": "If colour inversion (Classic Invert on an iPhone) turned the code light on dark, switch it off while showing the code."
},
"problem": {
"unsure": "If you can, make it dark on light: some scanners never look for light-on-dark codes.",
"graphic": "If you can, make it dark on light: some scanners never look for light-on-dark codes.",
"print": "If you can, print it dark on light: some scanners never look for light-on-dark codes.",
"screen": "If colour inversion (Classic Invert on an iPhone) turned the code light on dark, switch it off while showing the code."
}
}
}
},
"lighting": {
"name": "Lighting",
"what": "Whether light falls evenly on the code. A shadow’s edge or a bright reflection leaves one part darker or paler than the rest, so one line between dark and light no longer fits.",
"value_even": "No deep shadow or washed-out patch found",
"value_shadow": "Part of the code {shadow_pct} darker than the rest",
"value_shadow_graphic": "Light squares {shadow_pct} darker in part of the code: the file’s own colours, not a shadow",
"value_glare": "{glare_pct} of the code washed out to white",
"value_both": "{glare_pct} of the code washed out to white, and part of it {shadow_pct} darker than the rest",
"value_both_graphic": "{glare_pct} of the code washed out to white, and light squares {shadow_pct} darker in part of it",
"explain": {
"shadow": {
"watch": "A shadow: with part of the code 75% darker, the phones’ own scanners still read 9 in 10 test codes, but WeChat’s scanner read 63 of 80 and OpenCV’s two detectors fewer; at 85%, Google’s read 33.",
"watch_graphic": "Light squares this much darker in part of the code read like a shadow: with part of the code 75% darker, the phones’ own scanners still read 9 in 10 test codes, but WeChat’s scanner read 63 of 80 and OpenCV’s two detectors fewer; at 85%, Google’s read 33.",
"problem": "A shadow: with part of the code 85% darker, Google’s scanner read 33 of 80 test codes, and at 92%, none.",
"problem_graphic": "Light squares this much darker in part of the code read like a deep shadow: with part of the code 85% darker, Google’s scanner read 33 of 80 test codes, and at 92%, none."
},
"glare": {
"watch": "A bright patch: under a reflection that turned the middle of the code almost white, Android Settings’ scanner read 49 of 80 test codes; the phones’ own read 9 in 10 until it turned fully white.",
"problem": "A washed-out patch: once a reflection turned the middle of the code fully white, Google’s scanner read 68 of 80 test codes, and once it whitened a wider patch, the phones’ own read 2 to 8."
}
},
"advice": {
"shadow": {
"watch": {
"unsure": "Light the code evenly: move it, or the light, so no shadow falls across it.",
"graphic": "In a file this is a gradient or a picture behind the code: keep the area under it plain and evenly light.",
"print": "Place and light the code so no shadow falls across it, from a shelf edge, a frame or a hand.",
"screen": "Tilt the screen a little so reflections of the room fall off the code, and turn its brightness up."
},
"problem": {
"unsure": "Light the code evenly: move it, or the light, so no shadow falls across it.",
"graphic": "In a file this is a gradient or a picture behind the code: keep the area under it plain and evenly light.",
"print": "Place and light the code so no shadow falls across it, from a shelf edge, a frame or a hand.",
"screen": "Tilt the screen a little so reflections of the room fall off the code, and turn its brightness up."
}
},
"glare": {
"watch": {
"unsure": "Move the light, or the phone, so the bright reflection falls off the code.",
"graphic": "Keep highlights, shine effects and bright spots off the code.",
"print": "Choose a matte finish, not gloss or a shiny laminate, and place lights so their reflection doesn’t fall on the code.",
"screen": "Tilt the screen a little so the reflection moves off the code, and turn its brightness up."
},
"problem": {
"unsure": "Move the light, or the phone, so the bright reflection falls off the code.",
"graphic": "Keep highlights, shine effects and bright spots off the code.",
"print": "Choose a matte finish, not gloss or a shiny laminate, and place lights so their reflection doesn’t fall on the code.",
"screen": "Tilt the screen a little so the reflection moves off the code, and turn its brightness up."
}
}
}
},
"perspective": {
"name": "Angle",
"what": "How far the code is turned away from facing the camera. Turning squeezes the squares on the far side; scanners undo it using the corner squares.",
"value": "Turned about {tilt}° from facing the camera",
"value_keystone": "Far side {keystone_pct} shorter than the near side",
"value_facing": "Facing the camera, or close to it",
"explain": {
"tilt": {
"watch": "The phones’ own scanners read 9 in 10 test codes turned up to 55°, and Apple’s 49 of 80 at 60°; Android Settings’ only up to 30°.",
"problem": "Turned past where phones start to miss: at 60°, Apple’s scanner read 49 of 80 test codes, and at 70°, 7."
}
},
"advice": {
"tilt": {
"watch": {
"unsure": "Face the code more squarely. If people must scan it at a slant, making it bigger may help, since the slant squeezes its squares.",
"graphic": "The code is drawn at a slant: lay it flat and square in the file, and test angles with a photo of the print or screen.",
"print": "Place the code where people can face it: near eye level, on a flat surface, not high up or round a corner.",
"screen": "Hold the screen facing the camera, rather than tilted away."
},
"problem": {
"unsure": "Face the code squarely. If people must scan it at a slant, making it bigger may help, since the slant squeezes its squares.",
"graphic": "The code is drawn at a steep slant: lay it flat and square in the file, and test angles with a photo of the print or screen.",
"print": "Place the code where people can face it: near eye level, on a flat surface, not high up or round a corner.",
"screen": "Hold the screen facing the camera, rather than tilted away."
}
}
}
}
},
"placement": {
"label": "What does this picture show?",
"hint": "This picks what’s shown first, and the advice that fits. It never changes the level, its confidence or the checks.",
"note_sticky": "A new picture starts with your last choice only when that was a printed code or a code on a screen; an SVG always starts at Not sure.",
"options": {
"unsure": "Not sure",
"graphic": "The original graphic",
"print": "A printed code",
"screen": "A code on a screen"
},
"context": {
"unsure": "The level is for this picture as it is. Say what it shows for advice that fits.",
"graphic": "For a file, how wide to print it comes from its code’s share of it. Its level is for the file read as a picture, not a print.",
"print": "The level is for this photo. The print’s size, a glossy or matte finish, how flat it lies and the lighting change how other photos of it come out.",
"screen": "The level is for this photo. The screen’s brightness, glare and reflections, its pixels and how far it’s zoomed change how other photos of it come out."
},
"extra": {
"unsure": "",
"graphic": "Before printing many, print one, photograph it from where people will stand, and add the photo: it shows how hard the code is to read there.",
"print": "Before printing many, photograph a test print from where people will stand, in the light they’ll have, and add the photo.",
"screen": "Wavy bands across a photo of a screen come from its pixels meeting the camera’s; moving the phone a little closer, further away or to one side changes them."
}
},
"plan": {
"code": "A code like this needs printing at least {w} wide {to}.",
"code_floor": "A code like this needs printing at least {w} wide, likely more, {to}.",
"code_each": "Each code in this picture needs printing at least {w} wide {to}.",
"code_each_floor": "Each code in this picture needs printing at least {w} wide, likely more, {to}.",
"code_screen": "A code like this needs showing at least {w} wide {to}.",
"code_screen_floor": "A code like this needs showing at least {w} wide, likely more, {to}.",
"code_screen_each": "Each code in this picture needs showing at least {w} wide {to}.",
"code_screen_each_floor": "Each code in this picture needs showing at least {w} wide, likely more, {to}.",
"picture": "Print this picture at least {W} wide, so its code is {w}, {to}.",
"picture_floor": "Print this picture at least {W} wide, likely more, so its code is {w}, {to}.",
"picture_each": "Print this picture at least {W} wide, so each code in it is {w}, {to}.",
"picture_each_floor": "Print this picture at least {W} wide, likely more, so each code in it is {w}, {to}.",
"width": "At {W} wide, its code is {w}: it scans from up to {d}.",
"width_floor": "At {W} wide, its code is {w}: it scans from up to about {d}, likely less.",
"width_each": "At {W} wide, each code in it is {w}: each scans from up to {d}.",
"width_each_floor": "At {W} wide, each code in it is {w}: each scans from up to about {d}, likely less.",
"width_near": "At {W} wide, its code is {w}: too small to scan from {lo} or further.",
"width_near_each": "At {W} wide, each code in it is {w}: too small to scan from {lo} or further.",
"screen": "Measured on printed codes only.",
"cant": "No scanner reported this code’s version, so its width can’t be planned.",
"cant_override": "The checks don’t agree with the version zxing-cpp read for this code, so its width can’t be planned.",
"cant_estimate": "The checks estimate version {v}.",
"estimated": "By the checks’ estimate of its version, {answer}",
"estimate_line": "The checks estimate this code’s version from its own patterns: version {v}. The width rests on that.",
"repeats": "This picture repeats one code: zxing-cpp read {k} copies of it.",
"repeats_most": "This picture repeats one code: zxing-cpp read {k} copies of it, the most it reads in one picture.",
"margin": "Leave {m} of plain, light space round the code on every side.",
"margin_each": "Leave {m} of plain, light space round each code on every side.",
"problem_one": "The width assumes the Problem with its {names} is fixed.",
"problem_many": "The width assumes the Problems with its {names} are fixed.",
"missed": "{who} missed about 1 scan in {n} at {lo}–{hi} camera pixels per square, the most measured.",
"assume": "For a plain code, printed and read by {names} scanners in a quick everyday scan, with a phone’s main camera facing it.",
"assume_floor": "For a plain code, an estimate from version {v}’s need, read by {names} scanners in a quick everyday scan: versions over {v} aren’t measured.",
"owner": {
"apple-vision": "Apple’s",
"google": "Google’s",
"hms-scankit": "Huawei’s"
},
"file_reading": "This file read as a picture, not a print",
"file_tip": "This file read as a picture, not a print: {verdict}",
"suggest_file": "This looks like a file: mark it as the original graphic to see how wide to print it.",
"suggest_repeat": "If this is the file, mark it as the original graphic to see how wide to print the whole picture.",
"suggest_photo": "This looks like a photo: mark it as printed or on a screen to see how hard it is to read.",
"unit": {
"cm": "{n} cm",
"mm": "{n} mm",
"m": "{n} m",
"under_mm": "under 1 mm",
"under_cm": "under 1 cm",
"in": "{n} in",
"ft": "{ft} ft",
"ft_in": "{ft} ft {n} in",
"both": "{metric} ({imperial})"
},
"distance_summary": "Scanning from closer or further?",
"distance_legend": "Scanning from",
"distance": {
"hand": {
"label": "In hand, {d}",
"to": "to scan in hand, {d} away",
"short": "to scan in hand"
},
"table": {
"label": "A table, {d}",
"to": "to scan from a table, {d} away",
"short": "to scan from a table"
},
"wall": {
"label": "A wall, {d}",
"to": "to scan on a wall from {d} away",
"short": "to scan from {d}"
},
"room": {
"label": "Across a room, {d}",
"to": "to scan from across a room, {d} away",
"short": "to scan from {d}"
},
"exact": {
"to": "to scan from {d} away",
"short": "to scan from {d}"
}
},
"exact_summary": "An exact distance",
"exact_label": "From the phone to the code, in cm",
"exact_hint": "From {lo} to {hi}.",
"exact_invalid": "Give a number from {lo} to {hi}.",
"width_summary": "Know how wide it’ll be?",
"width_label": "The whole picture’s printed width",
"width_unit": "Unit",
"width_hint": "From {lo} to {hi}. The answer becomes how far its code scans from.",
"width_invalid": "Give a number from {lo} to {hi}.",
"width_invalid_in": "Give inches as a number, such as 1.25, or in eighths, such as 1 1/4, from {lo} to {hi}.",
"row": {
"code": "{w} or wider",
"code_floor": "{w} or wider, likely more",
"code_to": "its code, {to}",
"code_to_each": "each code, {to}",
"screen_to": "its code on a screen, {to}",
"screen_to_each": "each code on a screen, {to}",
"picture": "Print {W} or wider",
"picture_floor": "Print {W} or wider, likely more",
"width": "Scans up to {d} away",
"width_floor": "Up to about {d} away, likely less",
"width_near": "Too small to scan from {lo}",
"width_at": "at {W} wide",
"cant": "Width can’t be planned",
"estimated": "{why}, by an estimated version"
},
"how": {
"summary": "How this is worked out",
"version": "Version {v}: {n} squares across, as a scanner reported it.",
"version_estimate": "Version {v}: {n} squares across, as the checks estimate it from the code’s own patterns.",
"need": "It needs {p} camera pixels per square: the fewest from which {names} scanners each read at least {pass} of {of} test codes at every larger step, in a quick everyday scan.",
"from_next": "Version {v} wasn’t measured, so it takes version {at}’s need, the next measured version up.",
"from_one": "Version 1 takes version {at}’s need.",
"from_floor": "Versions over {at} weren’t measured: version {at}’s need is a floor, and the real need is likely more.",
"step": "Each need is a measured step, so the true 9-in-10 point can sit up to one step lower.",
"formula": "Code width = squares across × camera pixels per square × distance ÷ {px} = {n} × {p} × {d} ÷ {px}: {w}.",
"formula_far": "Farthest distance = code width × {px} ÷ (squares across × camera pixels per square) = {w} × {px} ÷ ({n} × {p}): {d}.",
"share": "Its code is {share} of the picture’s width, which sets the picture’s own width.",
"share_each": "Each code is {share} of the picture’s width, which sets the picture’s own width.",
"share_width": "Its code is {share} of the picture’s width: {w} at {W}.",
"share_width_each": "Each code is {share} of the picture’s width: {w} at {W}.",
"camera": "The {px} is an assumption, untested on real phones: a phone’s main camera ({lo}–{hi} mm equivalent) sees a patch about as wide as its distance, in portrait, and its scanner gets it as a {fw} × {fh} picture. That puts {px} pixels across the patch: about {ppmm} pixels per mm at {d}.",
"scene": "A quick everyday scan, as simulated: turned {tilt}°, focus blur {blur} pixels, a {shake}-pixel shake streak, {contrast} contrast, uneven light and JPEG quality {jpeg}.",
"bigger": "Measured at version {v} with {names} scanners, a {frame}-pixel camera picture reached {everyday} further in a quick everyday scan, and {good} further in good light. By pixel count alone, apps using {sw} × {sh} pictures would get about {small} of the reach; that isn’t measured.",
"about_pct": "about {p}%",
"pct_range": "{lo}–{hi}%",
"near": "No closer than about {near}: there the code and its margin would fill the camera’s view.",
"table_caption": "Code widths at each measured version’s need",
"table_version": "Version (squares)",
"table_need": "Pixels per square",
"table_row": "{v} ({n})",
"sheet": "Print a test sheet to check these widths with your own phone"
},
"shape": {
"summary": "At a slant, or on a can or bottle?",
"legend": "How the code faces the phone",
"kind": {
"flat": "Flat, facing the phone",
"slant": "At a slant",
"can": "On a can or bottle"
},
"deg_label": "Turned from facing the phone, in degrees",
"deg_hint": "From {lo} to {hi}. Every width already allows a code turned {scene}°, as in a quick everyday scan.",
"deg_invalid": "Give a number from {lo} to {hi}: phones’ scanners were tested turned up to {hi}°, so no width is given past that.",
"dia_label": "Its diameter where the code goes",
"dia_hint": "From {lo} to {hi}.",
"at": {
"slant": "Turned {deg}°, {answer}",
"can": "On a can or bottle {D} across, {answer}"
},
"cant": {
"slant": "Turned {deg}° from facing the phone, a code like this can’t be planned: at the width it would need, it wouldn’t fit in a phone camera’s view.",
"can": "On a can or bottle {D} across, a code like this can’t be planned {to}: it would need to wrap further round than tested.",
"can_width": "At {W} wide, its code is {w}, too wide for a can or bottle {D} across: it would wrap further round than tested.",
"can_width_each": "At {W} wide, each code in it is {w}, too wide for a can or bottle {D} across: it would wrap further round than tested."
},
"line": {
"scene": "Every width already allows a code turned {scene}°, as in a quick everyday scan, so this one doesn’t change.",
"slant_most": "It can be planned turned up to {most}°.",
"can_most": "On a can or bottle that size, it can be planned to scan from up to {d} away.",
"can_none": "On a can or bottle that size, it can’t be planned from {lo} or further.",
"can_max": "On a can or bottle that size, a code can be at most {w} wide."
},
"row": {
"slant": "{why}, turned {deg}°",
"can": "{why}, on a can or bottle {D} across",
"cant_slant": "Can’t be planned turned {deg}°",
"cant_can": "Can’t be planned on a can or bottle {D} across"
},
"how": {
"slant": "Turned {deg}°, the far side of the code is squeezed and further from the phone. To keep the camera pixels per square it gets turned {scene}°, as in a quick everyday scan, it needs printing {k} times as wide: {w}.",
"slant_far": "Turned {deg}°, the far side of the code is squeezed and further from the phone. To keep the camera pixels per square it gets turned {scene}°, as in a quick everyday scan, it must be scanned {k} times closer: from up to {d}.",
"slant_cos": "The squeeze alone would ask for {kc} times; the far side being further away asks for the rest, and more for bigger codes.",
"slant_fit": "A width is planned only while the code and its margin, turned that far, fit in the camera’s view, about {fov}° across: version {v} fits turned up to {most}°.",
"slant_tested": "Phones’ scanners were tested turned up to {most}°, on version {lv} codes at {lp} camera pixels per square: {names} scanners each read at least {pass} of {of} test codes there, and at {next}°, {who} read {n}. Past {most}°, no width is given.",
"can": "On a can or bottle {D} across, the code’s sides curve away from the phone, so its edge squares look narrower. At {w} wide, its edges sit {deg}° round it, where the phone sees each square {pct} as wide as at the middle, which keeps them at the need.",
"can_tested": "Phones’ scanners were tested on codes wrapped round a can down to a radius of {bend} code widths, on version {lv} codes at {lp} camera pixels per square: {names} scanners each read at least {pass} of {of} test codes there, and at {next}, {who} read {n}. So on a can or bottle {D} across, a code can be at most {wmax} wide.",
"can_afar": "The test codes were wrapped as seen from afar and straight on, so a can or bottle held close, or seen from above or below, may be harder than this."
},
"assume": "For a plain code, printed and read by {names} scanners in a quick everyday scan, with a phone’s main camera pointed at its middle."
}
},
"pair": {
"same": "Same code as picture {n}.",
"other_version": "Same content, but a different code: version {a} {la}, version {b} {lb}.",
"not_compared": "Not compared with your other pictures: its content can’t be matched.",
"margin": "Margin: {a} {la}, {b} {lb}.",
"contrast": "Contrast: {a} {la}, {b} {lb}.",
"ppm": "Camera pixels per square at 1280 pixels: {a} {la}, {b} {lb}.",
"level": "Level: {a} {la}, {b} {lb}.",
"uec": "Error correction used: {a} {la}, {b} {lb}.",
"unchanged": "Nothing compared differs: the {list} match.",
"unchanged_one": "Nothing compared differs: the {list} matches.",
"here": "here",
"in_file": "in the file",
"in_this_file": "in this file",
"in_picture": "in picture {n}",
"margin_full": "4 squares or more",
"margin_edge": "cut by the picture’s edge",
"uec_none": "none",
"name": {
"margin": "margin",
"contrast": "contrast",
"ppm": "camera pixels per square",
"uec": "error correction used",
"level": "level"
}
},
"made": {
"facts": {
"ec_margin": "As made: version {v} at error correction {ec}, {margin}.",
"ec": "As made: version {v} at error correction {ec}.",
"plain_margin": "As made: version {v}, {margin}.",
"plain": "As made: version {v}."
},
"margin": {
"some": "with a {m}-square margin",
"full": "with at least a {m}-square margin",
"none": "with no margin",
"under": "with less than a {m}-square margin"
},
"ec": {
"none": "It uses none of its error correction.",
"used": "It uses {u} of its error correction, so it may need printing wider: test a print before a big run.",
"all": "It uses all of its error correction, so it likely needs printing wider than a plain code, and even that may not be enough: test a print before a big run.",
"small": "It’s too small to judge how much of its error correction it uses: test a print before a big run.",
"shrunk": "This file was read shrunk to {fw} × {fh} pixels, where its code is too small to judge how much of its error correction it uses: a crop of the file that holds the code and its margin can be judged.",
"unjudged": "How much of its error correction it uses couldn’t be judged: test a print before a big run."
},
"smaller": "Its content fits version {v2}, which needs printing at least {w2} wide instead of {w}.",
"smaller_floor": "Its content fits version {v2}, which needs printing at least {w2} wide, likely more, instead of {w}.",
"more_summary": "Where these come from",
"more": {
"mask": "It uses mask {mask}, one of the QR standard’s eight patterns (numbered 0 to 7) that flip some of its data squares to break up shapes a scanner could misread.",
"uec_own": "zxing-cpp found {left} of its error correction unused, reading the file at its own {fw} × {fh} pixels.",
"uec": "zxing-cpp found {left} of its error correction unused, reading the file shrunk to {fw} × {fh} pixels, the largest size it read it at.",
"rule": "That’s judged only where the code has at least {min} pixels per square in the picture zxing-cpp read, since plain code files made without smoothing read with all of it unused from about there; a plain code resized with smoothing, or photographed, can read some as used at any size.",
"capacity": "Version {v2} comes from the QR standard’s capacity tables: the smallest version that holds the whole content in one mode at error correction {ec}, with room for GS1’s FNC1 marker."
},
"record": {
"marked": "This file says how it was made, so it’s marked as the original graphic.",
"announce_named": "Picture {n}, {name}: {line}",
"art": {
"spare-data": "Its art is drawn in the code’s spare room, so it should use none of its error correction.",
"changes-squares": "Its art changes some squares on purpose, and relies on error correction to read them right.",
"drawn-over": "Lines are drawn over its squares, so some may read the wrong way."
},
"yet": "Yet {k} of its squares read the wrong way.",
"fill": "The link alone fits version {lv}, which needs printing {lw} wide; this code was made at version {v}, and its art fills the rest.",
"fill_floor": "The link alone fits version {lv}, which needs printing {lw} wide, likely more; this code was made at version {v}, and its art fills the rest.",
"fill_width": "The link alone fits version {lv}; this code was made at version {v}, and its art fills the rest.",
"capitals": {
"whole-link": "Its link was put in capitals to save squares, path included: check that it still opens the right page."
},
"dots": {
"large": "Its squares are drawn as dots, which some scanners read less well: test a print before a big run.",
"small": "Its squares are drawn as small dots, which phones’ scanners often missed in tests: make them bigger, or test a print before a big run.",
"varies": "Its squares are drawn as dots of different sizes, which haven’t been tested: test a print before a big run."
},
"more": {
"dots": "Tested on version 3 codes with solid corner patterns: Apple’s, Google’s and Huawei’s scanners each read at least 75 of 80 down to dots four tenths of a square wide, and 48 to 71 at three tenths. ZXing, as in Android’s Settings app, read 70 of 80 already at nine tenths."
},
"repeats": "This picture repeats one code, each {p} pixels per square.",
"control": "The file says the control for this is “{control}”.",
"aside": {
"saved": "This file was saved again after it was made, so its details are ignored.",
"unreadable": "The file’s details couldn’t be read, so they’re ignored.",
"unchecked": "The file’s details couldn’t be checked against its code, so they’re ignored.",
"mismatch": "The file’s details don’t match its code, so they’re ignored.",
"newer": "The file’s details are in a newer form than this page reads."
}
},
"squares": {
"all": "All {N} squares read as made.",
"wrong": "{k} of its {N} squares read the wrong way ({pct}), {f} of them in the corner patterns.",
"wrong_clear": "{k} of its {N} squares read the wrong way ({pct}), none of them in the corner patterns.",
"mirrored": "This code is mirrored: flip it the right way round before printing.",
"more": {
"how": "The squares are counted against the squares the file says were meant, as zxing-cpp read them before error correction.",
"fixed": "{g} of the squares that read the wrong way are in its other fixed patterns, which every code has in the same place: its timing lines, its alignment patterns, the light borders round its corner patterns and the one square that is always dark.",
"fixed_one": "One of the squares that read the wrong way is in its other fixed patterns, which every code has in the same place: its timing lines, its alignment patterns, the light borders round its corner patterns and the one square that is always dark.",
"fixed_none": "None of the squares that read the wrong way is in its other fixed patterns, which every code has in the same place: its timing lines, its alignment patterns, the light borders round its corner patterns and the one square that is always dark."
}
}
},
"test": {
"hint": "It’s scanned beside a plain code with the same content in {s} simulated everyday scenes, {at}.",
"at": {
"width": "At that width",
"distance": "From that distance",
"width_lower": "at that width",
"distance_lower": "from that distance",
"flat": "At the width a flat code needs",
"flat_lower": "at the width a flat code needs"
},
"hint_browser": "{name} in this browser joins in: this browser downloads about {mb} MB of test pictures for it.",
"hint_offer": "{name} in this browser can join in: this browser would download about {mb} MB of test pictures for it.",
"add": "Add {name}",
"leave": "Leave it out",
"running": "Testing… {k} of {s} scenes",
"announce": "Testing the design.",
"announce_named": "Picture {n}, {name}: {line}",
"queued": "Waiting to be tested.",
"waiting": "The test is busy just now: try again in a few minutes.",
"busy": "Another design is being tested: this one starts by itself in about {n} seconds.",
"late": "It couldn’t finish in time: try again later.",
"like": "{at}, {who} read it as well as a plain code.",
"worse": "{at}, {who} read it worse than a plain code. Printing it wider or styling it more plainly may help: scan a test print with a few phones before a big run.",
"unsure": "{at}, the test couldn’t tell whether {who} read it as well as a plain code: scan a test print with a few phones before a big run.",
"missing": {
"google": "Google’s scanner wasn’t in this test: test it in Chrome on an Android phone for its answer.",
"google_no_android": "Google’s scanner wasn’t in this test, and can’t join a test of this code: scan a test print with a few phones.",
"apple": "Apple’s scanner wasn’t in this test: test it in Chrome on a Mac for its answer.",
"mac": "Phones’ scanners weren’t in this test, and can read such designs worse: test it in Chrome on this Mac for Apple’s answer, or scan a test print with a few phones.",
"mac_none": "Phones’ scanners weren’t in this test, and can read such designs worse: this browser has none the test can use, but Chrome on an Android phone gives Google’s answer; or scan a test print with a few phones.",
"mac_none_no_android": "Phones’ scanners weren’t in this test, and can read such designs worse: this browser has none the test can use, so scan a test print with a few phones.",
"android_none": "Phones’ scanners weren’t in this test, and can read such designs worse: this browser has none the test can use, but Chrome on a Mac gives Apple’s answer; or scan a test print with a few phones.",
"other": "Phones’ scanners weren’t in this test, and can read such designs worse: test it in Chrome on a Mac or an Android phone for Apple’s or Google’s answer, or scan a test print with a few phones.",
"other_no_android": "Phones’ scanners weren’t in this test, and can read such designs worse: test it in Chrome on a Mac for Apple’s answer, or scan a test print with a few phones.",
"save_data": "This browser asks to save data, so its scanner wasn’t in this test, and phones’ scanners can read such designs worse: turn data saving off, then try again, or scan a test print with a few phones.",
"left_out": "{name} was left out of this test to save data, and phones’ scanners can read such designs worse: add it to test again, or scan a test print with a few phones."
},
"fallback": {
"start": "{name} didn’t start in this browser this time, so it wasn’t in this test, and phones’ scanners can read such designs worse: try again to bring it back, or scan a test print with a few phones.",
"stopped": "{name} stopped partway, so it wasn’t in this test, and phones’ scanners can read such designs worse: try again, or scan a test print with a few phones.",
"slow": "The test pictures came too slowly for {name}, so it wasn’t in this test, and phones’ scanners can read such designs worse: try again on a faster connection, or scan a test print with a few phones."
},
"cant": {
"facts": "It can’t be tested: a plain code needs its error correction and mask, which zxing-cpp didn’t read. Scan a test print with a few phones before a big run.",
"inverted": "Light-on-dark codes can’t be tested here: the test compares a design with a dark-on-light plain code. Scan a test print with a few phones before a big run.",
"mirrored": "This code is mirrored: flip it the right way round before printing.",
"small": "Export it with at least {min} pixels per square to test it.",
"small_svg": "Add a crop of the SVG that holds the code and its margin to test it.",
"big": "Export it at {mp} megapixels or fewer to test it.",
"version": "Versions over {max} can’t be tested here yet: scan a test print with a few phones before a big run.",
"several": "It can’t be tested: it holds more than one code. Add a crop of the file that holds one code and its margin.",
"twin": "It can’t be tested: a plain code of the same content couldn’t be made. Scan a test print with a few phones before a big run.",
"differ": "It can’t be tested: the test read its code differently from the first reading. Scan a test print with a few phones before a big run."
},
"name": {
"apple": "Apple’s scanner",
"google": "Google’s scanner",
"zxing-cpp": "zxing-cpp",
"wechat": "WeChat’s scanner"
},
"more_summary": "How this was tested",
"more": {
"method": "The design, with up to {margin} squares of it round its code, and a plain code with the same content, version, error correction and mask were each scanned in the same {s} simulated scenes: the quick everyday scan the width is worked out for, with each square at {p} camera pixels, version {v}’s need.",
"rule": "Each scanner is judged on its own, scene by scene. It read the design worse when it missed the design where it read the plain code too often to put down to chance: in at least {least} scenes with none the other way round, or more when there are some. It read it as well as a plain code when that happened at most {cost} more times than the other way round, and it read the plain code, or the design, in at least {q} scenes. Otherwise it couldn’t tell. One scanner reading it worse is enough.",
"each": "{name}: {result}.",
"result": {
"like": "as well as a plain code",
"worse": "worse than a plain code",
"close": "a little worse, too little to be sure",
"few": "too few scenes read to compare"
},
"apple": "Apple’s scanner here is the one Chrome uses on a Mac, built into macOS. In tests, Chrome on macOS {os} read {n} of {n} simulated scans exactly as Apple’s scanner did on its own. Other versions may read differently, but it read the plain code too, so the two still compare.",
"google": "Google’s scanner here is the one Chrome uses on Android phones with Google Play. In tests on an Android {os} emulator with Google Play, Chrome read {n} of {n} simulated scans exactly as Google’s scanner did on its own. Other versions may read differently, but it read the plain code too, so the two still compare.",
"cover_open": "In tests on {N} designs from one code generator, zxing-cpp and WeChat’s scanner read {y} as well as a plain code. Apple’s or Google’s scanner read {x} of those worse, and couldn’t tell for {z} more.",
"cover_open_worse": "Of the {y} that zxing-cpp or WeChat’s scanner read worse in those tests, Apple’s or Google’s read {x} worse too.",
"cover_apple": "In tests on {N} designs from one code generator, Apple’s scanner, zxing-cpp and WeChat’s read {y} as well as a plain code. Google’s scanner read {x} of those worse, and couldn’t tell for {z} more.",
"cover_google": "In tests on {N} designs from one code generator, Google’s scanner, zxing-cpp and WeChat’s read {y} as well as a plain code. Apple’s scanner read {x} of those worse, and couldn’t tell for {z} more.",
"limits": "{s} scenes show big differences, not small ones: a design that misses {big} of the scans a plain code reads still gets “as well as a plain code” about {big_pass}, and one that misses {small}, about {small_pass}.",
"limits_share": "{a} in {b}",
"limits_times_one": "{a} time in {b}",
"limits_times_many": "{a} times in {b}",
"scope": "The test pictures are simulated scans of a print, read as still pictures: no phone’s camera or app took part. The figures above come from {N} designs from one code generator, in {styles} styles at versions {vlo} to {vhi}.",
"private": "What this browser’s scanner read stayed in this page."
},
"privacy": "A picture marked as the original graphic is sent again for its design test, and when this browser can read the test’s simulated scans and its scanner joins in, it fetches them from the server and reads them here. Nothing is kept.",
"choice_hint": "The original graphic also starts a design test, which sends the picture again.",
"how_scanners": "In Chrome on a Mac or an Android phone, a design test can add Apple’s or Google’s in your own browser."
},
"try": {
"title": "What to try",
"general": [
"Check that the picture holds a QR code: one with no code, or with another kind of barcode, lands here too."
],
"photo": "Take another picture: closer, steady, in even light, with the code facing the camera.",
"unsure": "",
"graphic": "Export the file again bigger, dark on light, with 4 squares of plain margin on every side.",
"graphic_big": "Files are read at no more than {px} pixels on their long side, so a small code in a big design can get too few pixels to read: add a crop of the file that holds the code and its margin. Its answer is the code’s width; print the design with its code at least that wide.",
"graphic_look": "Keep the code dark on light, with 4 squares of plain margin on every side.",
"print": "If the print is worn, smudged, creased or curved, try a fresh, flat copy, and keep shadows and glare off it.",
"screen": "Turn the screen’s brightness up, tilt it so no reflection falls on the code, and zoom in so the code is bigger."
},
"rows": {
"no_code": "None of the five found a code; if it holds one, it’s Advanced.",
"partial": "Some reads didn’t finish in time.",
"empty_file": "This file is empty.",
"waiting": "Waiting to be read",
"reading": "Reading at seven sizes…",
"again": "Try again",
"remove": "Remove {name}",
"remove_all": "Remove all",
"content_bytes": "Content that isn’t text, {bytes} bytes",
"pasted": "Pasted picture {n}"
},
"add": {
"note": "Read by five of the eight scanners. Nothing is kept.",
"reading": "Reading picture {n}…",
"more": "{n} more to read.",
"waiting": "{n} waiting to be read.",
"paused": "{n} waiting until you try again.",
"too_many": "Up to {max} pictures at a time: {n} not added.",
"not_picture": "One file isn’t a picture.",
"not_pictures": "{n} files aren’t pictures."
},
"errors": {
"busy": "The server couldn’t read it just now.",
"unreadable": "This picture couldn’t be read.",
"unreachable": "Couldn’t reach the server.",
"svg": "This SVG couldn’t be drawn here. Export it as a PNG and add that.",
"svg_links": "This SVG uses other files, such as linked pictures or fonts, which can’t be loaded here. Export it as a PNG and add that.",
"svg_dark": "This SVG has its own colours for dark mode, which this browser is using, so it can’t be drawn as it prints. Export it as a PNG and add that.",
"too_big": "This picture is over {mb} MB.",
"format": "This browser can’t open this picture’s format. Try a JPEG or PNG.",
"prepare": "This picture couldn’t be prepared for reading.",
"too_big_converted": "This picture is over {mb} MB once converted for reading."
},
"read": {
"announce": "Picture {n}, {name}, read: {verdict}",
"announce_failed": "Picture {n}, {name}, couldn’t be read: {error}"
},
"how": {
"index_html": {
"pile_hi_add": "A picture none of the five read at any size goes to the pile on the right, where its place is least sure, though not its level if it holds a code: of the {hi_n} measured codes like it, all holding one, {hi_pct} were Advanced for all eight scanners too.",
"dashed": "A dashed line means low confidence; a reading cut short by the time limit is always low.",
"levels": "Each picture also gets a level from its difficulty: Easy below {c1}, Everyday from {c1}, Tough from {c2} and Advanced from {c3}; the pile on the left is Easy and the pile on the right Advanced. On the curve, the levels line up with the simulated prints: most clean prints are Easy ({clean_easy} of {clean_n}), most everyday prints Everyday ({everyday_everyday} of {everyday_n}) and most tough prints Tough ({tough_tough} of {tough_n}). Beside your picture, its level is described by measured codes in pictures of the same size: those over 1280 pixels on the long side, as a full-size phone photo is, are mostly simulated prints, and smaller ones mostly research images. For a picture in the pile on the right it is described by the pile’s own codes instead, both sizes together, because the codes the five place at Advanced were read far more often.",
"confidence": "Its confidence, high, medium or low, says how far to trust the level. The five scanners here stand in for eight: on the measured codes, the level from the five’s reads matched the one from all eight for {agree_m} of {agree_n}. A picture’s confidence is how often that held for measured codes read like it. For a picture in a pile, those are the codes in the same pile. Otherwise they are codes read by as many of the five at 1280 pixels (fewer than two, or more) that sit about as close to a level boundary; with two or more reads, they are also in pictures of the same size class (over 1280 pixels on the long side, or not) and, near a boundary, on the same side of it, except that a picture over 1280 pixels near the Advanced boundary counts with those just below it. It is high where at least {high} matched, medium from {medium}, and low below that. A reading cut short by the time limit is always low, and one where OpenCV’s newer detector wasn’t run at some sizes, on a picture with many codes, is at most medium. Confidence covers only the stand-in, not the photo: another photo of the same code can land at another level.",
"checks": "The checks measure the picture where the scanners found the code: camera pixels per square, size, margin, sharpness, contrast, lighting and angle. Their limits come from QR Scan Difficulty’s factor tests, where one code all eight scanners read was changed one thing at a time, with 80 test codes a step read at 1280 pixels. A check is Fine where all eight read 9 in 10 test codes like it, Borderline where the phones’ own scanners did but at least one other didn’t, and a Problem where one of the phones’ own didn’t. Each limit sits halfway between the check’s typical values on the last step with one status and the first step with the next; where two tests set one limit, it sits in the middle of the range both allow. Pixels per square takes its limits from the tests the widths come from, in good light, and its Problem limit rises with the code’s version. The margin follows the QR standard’s 4 squares instead, and a code that fills much of the picture gets a note about framing, not a status. The checks explain and advise; they never change the level or its confidence.",
"details": "Before a picture is sent, this browser removes the details its file carries, such as where and when a photo was taken and on which phone. It keeps only what the reading needs, such as which way up a photo goes.",
"selector": "Each picture whose version a scanner reported, or the checks estimate, also gets how wide to print its code for a scanning distance: from the version, the camera pixels per square that Apple’s, Google’s and Huawei’s scanners were measured to need at that version in a quick everyday scan (Apple’s and Google’s alone from version 16), and an assumed phone camera. It is an estimate, never a promise that a phone will scan. You can say what a picture shows: the original graphic, a printed code or a code on a screen. That picks what is shown first, and the advice: for the original graphic, how wide to print the picture itself. It never changes the level, its confidence or the checks, and the choice, the distance and any width, slant or diameter you give stay in your browser. A file whose own details check out is marked as the original graphic by itself, and this browser reads those details and removes them before the picture is sent.",
"selector_test": "Each picture whose version a scanner reported, or the checks estimate, also gets how wide to print its code for a scanning distance: from the version, the camera pixels per square that Apple’s, Google’s and Huawei’s scanners were measured to need at that version in a quick everyday scan (Apple’s and Google’s alone from version 16), and an assumed phone camera. It is an estimate, never a promise that a phone will scan. You can say what a picture shows: the original graphic, a printed code or a code on a screen. That picks what is shown first, and the advice: for the original graphic, how wide to print the picture itself. It never changes the level, its confidence or the checks, and the choice, the distance and any width, slant or diameter you give stay in your browser, except that marking a picture as the original graphic starts a design test, which sends the picture again. A file whose own details check out is marked as the original graphic by itself, and this browser reads those details and removes them before the picture is sent."
},
"lede": "Add a picture of your QR code, the file or a photo of it, to see how wide to print it, how hard it is to scan, and why.",
"meta_description": "Where does your QR code fall among thousands of measured codes? Add a picture: five open-source scanners read it at seven sizes, place it on the scale eight scanners set, and rate it Easy, Everyday, Tough or Advanced."
},
"sheet": {
"kicker": "QR scan difficulty · test sheet",
"title": "How small a code does your phone read?",
"print_line": "Print this page at 100% (actual size), not fitted to the page. Printed true, the bar below measures {cm} along its top edge and {inches} along its bottom edge: if it doesn’t, print it again.",
"print": "Print this sheet",
"private": "Nothing is collected: each code holds a line of plain text, not a web address, so scanning one sends nothing to this site.",
"framed": "Open the sheet in a tab of its own to print it true to size.",
"screen": "On a screen these sizes aren’t true: test the printed sheet.",
"bar_name": "A bar {cm} long along its top edge and {inches} along its bottom edge",
"test": "Lay the sheet flat and hold your phone {d} from it. Scan the codes from the largest down, covering the others with your hand: each holds a line of text naming its width, so if your phone shows the text, you can tell which it read.",
"expect": "If your phone needs a bigger code than the one planned for {d}, print your codes at least that much wider than planned: a quick everyday scan, turned and less steady, asks for more than this careful one.",
"planned": "Planned for {d}",
"code_name": "Code {k} of {count}, {w} wide",
"foot": "From QR Scan Difficulty Check, huggingface.co/spaces/devmandan/qr-scan-difficulty-check. Plain codes at version {v}, {n} squares across, and error correction {ec}, each with a {q}-square margin.",
"more_summary": "How these widths are chosen",
"more": {
"codes": "Each is a plain version {v} code, {n} squares across, at error correction {ec}, with a {q}-square margin, made with zxing-cpp’s encoder like the codes the widths were measured on. Its text needs version {v} at that error correction.",
"middle": "The middle code is the width this page plans for version {v} {to}, as for any picture of a version {v} code:",
"steps": "The others step by about 1.4 times, the square root of 2: down to half of it, the width planned in hand, {hand} away, and up to twice it, what apps using {sw} × {sh} camera pictures would need by pixel count alone (that isn’t measured).",
"far": "By the same rule, the five scan from up to {list}, so you can also test each from its own distance.",
"design": "These are plain codes. A styled design can need more: to check one, print the design itself and scan it the same way.",
"private": "Opening this sheet fetches only its own files, the same for everyone, and this server keeps no access log; Hugging Face, which hosts it, has its own privacy policy. The codes hold plain text only, not a web address."
},
"back": "Back to the check"
}
}
|