public static QrCode EncodeText(string text, Ecc ecl) { Utils.CheckNull(text, nameof(text)); var segs = QrSegment.MakeSegments(text); return(EncodeSegments(segs, ecl)); }
/// <summary> /// Creates a QR code representing the specified text using the specified error correction level. /// <para> /// As a conservative upper bound, this function is guaranteed to succeed for strings with up to 738 /// Unicode code points (not UTF-16 code units) if the low error correction level is used. The smallest possible /// QR code version (size) is automatically chosen. The resulting ECC level will be higher than the one /// specified if it can be achieved without increasing the size (version). /// </para> /// </summary> /// <param name="text">The text to be encoded. The full range of Unicode characters may be used.</param> /// <param name="ecl">The minimum error correction level to use.</param> /// <returns>The created QR code instance representing the specified text.</returns> /// <exception cref="ArgumentNullException"><paramref name="text"/> or <paramref name="ecl"/> is <c>null</c>.</exception> /// <exception cref="DataTooLongException">The text is too long to fit in the largest QR code size (version) /// at the specified error correction level.</exception> public static QrCode EncodeText(string text, Ecc ecl) { Objects.RequireNonNull(text); Objects.RequireNonNull(ecl); List <QrSegment> segs = QrSegment.MakeSegments(text); return(EncodeSegments(segs, ecl)); }
/// <summary> /// Creates a QR code representing the specified binary data using the specified error correction level. /// <para> /// This function encodes the data in the binary segment mode. The maximum number of /// bytes allowed is 2953. The smallest possible QR code version is automatically chosen. /// The resulting ECC level will be higher than the one specified if it can be achieved without increasing the size (version). /// </para> /// </summary> /// <param name="data">The binary data to encode.</param> /// <param name="ecl">The minimum error correction level to use.</param> /// <returns>The created QR code representing the specified data.</returns> /// <exception cref="ArgumentNullException"><paramref name="data"/> or <paramref name="ecl"/> is <c>null</c>.</exception> /// <exception cref="DataTooLongException">The specified data is too long to fit in the largest QR code size (version) /// at the specified error correction level.</exception> public static QrCode EncodeBinary(byte[] data, Ecc ecl) { Objects.RequireNonNull(data); Objects.RequireNonNull(ecl); QrSegment seg = QrSegment.MakeBytes(data); return(EncodeSegments(new List <QrSegment> { seg }, ecl)); }
private static List <QrSegment> SplitIntoSegments(int[] codePoints, Mode[] charModes) { if (codePoints.Length == 0) { throw new ArgumentException(); } var result = new List <QrSegment>(); // Accumulate run of modes var curMode = charModes[0]; int start = 0; for (int i = 1; ; i++) { if (i < codePoints.Length && charModes[i] == curMode) { continue; } var s = FromCodePoint(codePoints, start, i - start); if (curMode == Mode.BYTE) { result.Add(QrSegment.MakeBytes(Encoding.UTF8.GetBytes(s))); } else if (curMode == Mode.NUMERIC) { result.Add(QrSegment.MakeNumeric(s)); } else if (curMode == Mode.ALPHANUMERIC) { result.Add(QrSegment.MakeAlphanumeric(s)); } else if (curMode == Mode.KANJI) { result.Add(MakeKanji(s)); } else { throw new ApplicationException(); } if (i >= codePoints.Length) { return(result); } curMode = charModes[i]; start = i; } }
public static List <QrSegment> MakeSegmentsOptimally(string text, Ecc ecl, int minVersion, int maxVersion) { Utils.CheckNull(text, nameof(text)); if (!(QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= QrCode.MAX_VERSION)) { throw new ArgumentException("Invalid value"); } List <QrSegment> segs = null; var codePoints = ToCodePoints(text); for (int version = minVersion; ; version++) { if (version == minVersion || version == 10 || version == 27) { segs = MakeSegmentsOptimally(codePoints, version); } var dataCapacityBits = QrCode.GetNumDataCodewords(version, ecl) * 8; var dataUsedBits = QrSegment.GetTotalBits(segs, version); if (dataUsedBits != -1 && dataUsedBits <= dataCapacityBits) { return(segs); } if (version >= maxVersion) { var msg = "Segment too long"; if (dataUsedBits != -1) { msg = String.Format("Data length = {0} bits, Max capacity = {1} bits", dataUsedBits, dataCapacityBits); } throw new DataTooLongException(msg); } } }
/// <summary> /// Creates a QR code representing the specified segments with the specified encoding parameters. /// <para> /// The smallest possible QR code version (size) is used. The range of versions can be /// restricted by the <paramref name="minVersion"/> and <paramref name="maxVersion"/> parameters. /// </para> /// <para> /// If <paramref name="boostEcl"/> is <c>true</c>, the resulting ECC level will be higher than the /// one specified if it can be achieved without increasing the size (version). /// </para> /// <para> /// The QR code mask is usually automatically chosen. It can be explicitly set with the <paramref name="mask"/> /// parameter by using a value between 0 to 7 (inclusive). -1 is for automatic mode (which may be slow). /// </para> /// <para> /// This function allows the user to create a custom sequence of segments that switches /// between modes (such as alphanumeric and byte) to encode text in less space and gives full control over all /// encoding paramters. /// </para> /// </summary> /// <remarks> /// This is a mid-level API; the high-level APIs are <see cref="EncodeText(string, Ecc)"/> /// and <see cref="EncodeBinary(byte[], Ecc)"/>. /// </remarks> /// <param name="segments">The segments to encode.</param> /// <param name="ecl">The minimal or fixed error correction level to use .</param> /// <param name="minVersion">The minimum version (size) of the QR code (between 1 and 40).</param> /// <param name="maxVersion">The maximum version (size) of the QR code (between 1 and 40).</param> /// <param name="mask">The mask number to use (between 0 and 7), or -1 for automatic mask selection.</param> /// <param name="boostEcl">If <c>true</c> the ECC level wil be increased if it can be achieved without increasing the size (version).</param> /// <returns>The created QR code representing the segments.</returns> /// <exception cref="ArgumentNullException"><paramref name="segments"/>, any list element, or <paramref name="ecl"/> is <c>null</c>.</exception> /// <exception cref="ArgumentOutOfRangeException">1 ≤ minVersion ≤ maxVersion ≤ 40 /// or -1 ≤ mask ≤ 7 is violated.</exception> /// <exception cref="DataTooLongException">The segments are too long to fit in the largest QR code size (version) /// at the specified error correction level.</exception> public static QrCode EncodeSegments(List <QrSegment> segments, Ecc ecl, int minVersion = MinVersion, int maxVersion = MaxVersion, int mask = -1, bool boostEcl = true) { Objects.RequireNonNull(segments); Objects.RequireNonNull(ecl); if (minVersion < MinVersion || minVersion > maxVersion) { throw new ArgumentOutOfRangeException(nameof(minVersion), "Invalid value"); } if (maxVersion > MaxVersion) { throw new ArgumentOutOfRangeException(nameof(maxVersion), "Invalid value"); } if (mask < -1 || mask > 7) { throw new ArgumentOutOfRangeException(nameof(mask), "Invalid value"); } // Find the minimal version number to use int version, dataUsedBits; for (version = minVersion; ; version++) { int numDataBits = GetNumDataCodewords(version, ecl) * 8; // Number of data bits available dataUsedBits = QrSegment.GetTotalBits(segments, version); if (dataUsedBits != -1 && dataUsedBits <= numDataBits) { break; // This version number is found to be suitable } if (version >= maxVersion) { // All versions in the range could not fit the given data string msg = "Segment too long"; if (dataUsedBits != -1) { msg = $"Data length = {dataUsedBits} bits, Max capacity = {numDataBits} bits"; } throw new DataTooLongException(msg); } } Debug.Assert(dataUsedBits != -1); // Increase the error correction level while the data still fits in the current version number foreach (Ecc newEcl in Ecc.AllValues) { // From low to high if (boostEcl && dataUsedBits <= GetNumDataCodewords(version, newEcl) * 8) { ecl = newEcl; } } // Concatenate all segments to create the data bit string BitArray ba = new BitArray(0); foreach (QrSegment seg in segments) { ba.AppendBits(seg.EncodingMode.ModeBits, 4); ba.AppendBits((uint)seg.NumChars, seg.EncodingMode.NumCharCountBits(version)); ba.AppendData(seg.GetData()); } Debug.Assert(ba.Length == dataUsedBits); // Add terminator and pad up to a byte if applicable int dataCapacityBits = GetNumDataCodewords(version, ecl) * 8; Debug.Assert(ba.Length <= dataCapacityBits); ba.AppendBits(0, Math.Min(4, dataCapacityBits - ba.Length)); ba.AppendBits(0, (8 - ba.Length % 8) % 8); Debug.Assert(ba.Length % 8 == 0); // Pad with alternating bytes until data capacity is reached for (uint padByte = 0xEC; ba.Length < dataCapacityBits; padByte ^= 0xEC ^ 0x11) { ba.AppendBits(padByte, 8); } // Pack bits into bytes in big endian byte[] dataCodewords = new byte[ba.Length / 8]; for (int i = 0; i < ba.Length; i++) { if (ba.Get(i)) { dataCodewords[i >> 3] |= (byte)(1 << (7 - (i & 7))); } } // Create the QR code object return(new QrCode(version, ecl, dataCodewords, mask)); }
public static QrCode EncodeSegments(List <QrSegment> segs, Ecc ecl, int minVersion, int maxVersion, int mask, bool boostEcl) { Utils.CheckNull(segs, nameof(segs)); if (!(MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= MAX_VERSION) || mask < -1 || mask > 7) { throw new ArgumentException("Invalid value"); } int version, dataUsedBits; for (version = minVersion; ; version++) { var capacityBits = GetNumDataCodewords(version, ecl) * 8; dataUsedBits = QrSegment.GetTotalBits(segs, version); if (dataUsedBits != -1 && dataUsedBits <= capacityBits) { break; } if (version >= maxVersion) { var msg = "Segment too long"; if (dataUsedBits != -1) { msg = string.Format("Data length = {0} bits, Max capacity = {1} bits", dataUsedBits, capacityBits); } throw new DataTooLongException(msg); } } foreach (var newEcl in new Ecc[] { Ecc.Low, Ecc.Medium, Ecc.Quartitle, Ecc.High }) { if (boostEcl && dataUsedBits <= GetNumDataCodewords(version, newEcl) * 8) { ecl = newEcl; } } var bb = new BitBuffer(); foreach (var seg in segs) { bb.AppendBits(seg.Mode.ModeBits, 4); bb.AppendBits(seg.NumChars, seg.Mode.NumCharCountBits(version)); bb.AppendData(seg.Data); } var dataCapacityBits = GetNumDataCodewords(version, ecl) * 8; bb.AppendBits(0, Math.Min(4, dataCapacityBits - bb.Length)); bb.AppendBits(0, (8 - bb.Length % 8) % 8); for (var padByte = 0xEC; bb.Length < dataCapacityBits; padByte ^= 0xEC ^ 0x11) { bb.AppendBits(padByte, 8); } var dataCodewords = new byte[bb.Length / 8]; for (var i = 0; i < bb.Length; i++) { dataCodewords[i >> 3] = (byte)(dataCodewords[i >> 3] | bb.GetBit(i) << (7 - (i & 7))); } // Create the QR Code object return(new QrCode(version, ecl, dataCodewords, mask)); }