private static int DataBits(int version, ErrorCorrectionLevel level)
{
int totalCodewords = VersionTable.GetVersionByNum(version).TotalCodewords;
int totalECCodewords = VersionTable.GetVersionByNum(version).GetECBlocksByLevel(level).NumErrorCorrectionCodewards;
return (totalCodewords - totalECCodewords) * 8;
}
public static VersionCheckStatus VersionCheck(int versionNum, int numDataBits, Mode mode, ErrorCorrectionLevel level, string encodingName)
{
int TotalDataBits = numDataBits;
ECISet eciSet = new ECISet(ECISet.AppendOption.NameToValue);
if(mode == Mode.EightBitByte)
{
if(encodingName != DEFAULT_ENCODING)
{
int eciValue = eciSet.GetECIValueByName(encodingName);
TotalDataBits += ECISet.NumOfECIHeaderBits(eciValue);
}
}
int bitCharCountIndicator = CharCountIndicatorTable.GetBitCountInCharCountIndicator(mode, versionNum);
TotalDataBits += (4 + bitCharCountIndicator);
int expectContainer = DataBits(versionNum, level);
int lowerContainer = versionNum == 1 ? 0 : DataBits(versionNum - 1, level);
if(expectContainer < TotalDataBits)
{
return VersionCheckStatus.SmallerThanExpect;
}
else if(lowerContainer >= TotalDataBits)
{
return VersionCheckStatus.LargerThanExpect;
}
else
{
return VersionCheckStatus.Efficient;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="QROptions"/> class.
/// </summary>
/// <param name="ec">Error correction level.</param>
/// <param name="margin">The margin (or blank space) around the QR code.</param>
public QROptions(ErrorCorrectionLevel ec, int margin)
{
_errorCorrectionLevel = ec;
// autocorrect margin if necessary
_margin = margin > MinimalMargin ? margin : MinimalMargin;
}
private FormatInformation(int formatInfo)
{
// Bits 3,4
errorCorrectionLevel = ErrorCorrectionLevel.forBits((formatInfo >> 3) & 0x03);
// Bottom 3 bits
dataMask = (sbyte) (formatInfo & 0x07);
}
public void Test_against_CSV_Dataset(int numDataBits, Mode mode, ErrorCorrectionLevel level, string encodingName, int expectVersionNum)
{
VersionControlStruct vcStruct = VersionControl.InitialSetup(numDataBits, mode, level, encodingName);
if(vcStruct.VersionDetail.Version != expectVersionNum)
Assert.Fail("Method return version number: {0} Expect value: {1}", vcStruct.VersionDetail.Version, expectVersionNum);
}
private void TestOneCase(string inputString, ErrorCorrectionLevel eclevel, IEnumerable<bool> expected)
{
EncodationStruct encodeStruct = DataEncode.Encode(inputString, eclevel);
IEnumerable<bool> actualResult = ECGenerator.FillECCodewords(encodeStruct.DataCodewords, encodeStruct.VersionDetail);
BitVectorTestExtensions.CompareIEnumerable(actualResult, expected, "string");
}
public VersionTestProperties(int numDataBits, Mode mode, ErrorCorrectionLevel level, string encodingName, int versionNum)
: this()
{
this.NumDataBitsForEncodedContent = numDataBits;
this.Mode = mode;
this.ECLevel = level;
this.EncodingName = encodingName;
this.ExpectVersionNum = versionNum;
}
public VersionTableTestProperties(int versionNum, int totalCodewords, ErrorCorrectionLevel level, int numECCodewords, string ecBlockString)
:this()
{
this.VersionNum = versionNum;
this.TotalNumOfCodewords = totalCodewords;
this.ErrorCorrectionLevel = level;
this.NumOfECCodewords = numECCodewords;
this.ECBlockString = ecBlockString;
}
/// <summary>
/// Given an input string, generates a QR code image.
/// </summary>
/// <param name="input">The textual data to turn into a QR code image. The text must contain only
/// printable US-ASCII characters.</param>
/// <param name="errorCorrectionLevel">The level of data redundancy to include in the generated
/// image. The default level is 'M' (approximately 15% redundancy).</param>
/// <returns>An Image corresponding to the generated QR code.</returns>
public static Image GetQRCode(string input, ErrorCorrectionLevel errorCorrectionLevel = ErrorCorrectionLevel.M)
{
ValidateInputString(input);
if (errorCorrectionLevel < ErrorCorrectionLevel.L || errorCorrectionLevel > ErrorCorrectionLevel.H)
{
throw new ArgumentOutOfRangeException("errorCorrectionLevel");
}
return Tester.GetQRCode(input);
}
/// <summary>
/// 根据文字内容等信息构建相应QRCode格式二维码图片
/// </summary>
/// <param name="content">二维码内容信息</param>
/// <param name="level">纠错级别</param>
/// <param name="width">图片宽度，如小于0则使用默认尺寸</param>
/// <param name="height">图片高度，如小于0则使用默认尺寸</param>
/// <param name="inline">内嵌图片，如为Null则不做内嵌</param>
/// <returns>二维码图片</returns>
public static Image BuildQRCode(String content, ErrorCorrectionLevel level, int width, int height, Image inline)
{
QrEncoder encoder = new QrEncoder(level);
QrCode code = null;
if (!encoder.TryEncode(content, out code))
return null;
GraphicsRenderer render = new GraphicsRenderer(new FixedModuleSize(ModuleSizeInPixels, QuietZoneModules.Two), Brushes.Black, Brushes.White);
DrawingSize cSize = render.SizeCalculator.GetSize(code.Matrix.Width);
Size oSize = new Size(cSize.CodeWidth, cSize.CodeWidth) + new Size(2 * PaddingSizeInPixels, 2 * PaddingSizeInPixels);
Image img = new Bitmap(oSize.Width, oSize.Height);
using (Graphics g = Graphics.FromImage(img))
{
g.CompositingQuality = CompositingQuality.HighQuality;
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
render.Draw(g, code.Matrix);
if (inline != null)
{
int iw = (int)(oSize.Width * InlineSizeInProportion);
int ih = (int)(oSize.Height * InlineSizeInProportion);
int il = (oSize.Width - iw) / 2;
int it = (oSize.Height - ih) / 2;
g.DrawImage(inline, it, il, iw, ih);
Pen pen = new Pen(Color.White, 1);
using (GraphicsPath path = CreateRoundedRectanglePath(new Rectangle(it - 1, il - 1, iw + 1, ih + 1), 4))
{
g.DrawPath(pen, path);
}
}
}
if (width > 0 && height > 0)
{
int w = width > 0 ? width : code.Matrix.Width;
int h = height > 0 ? height : code.Matrix.Height;
Image imgCode = new Bitmap(width, height);
using (Graphics g = Graphics.FromImage(imgCode))
{
g.CompositingQuality = CompositingQuality.HighQuality;
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
g.DrawImage(img, 0, 0, width, height);
}
img.Dispose();
img = imgCode;
}
return img;
}
public static VersionInfo FindSmallestVersionInfo(ErrorCorrectionLevel errorCorrectionLevel, EncodingMode encodingMode, int dataBits)
{
dataBits += 4; // Mode indicator
foreach (VersionInfo versionInfo in VersionInfos.Where(x => x.ErrorCorrectionLevel == errorCorrectionLevel))
{
if ((versionInfo.TotalDataBytes() * 8) >= (dataBits + (int)versionInfo.CharCountBits(encodingMode)))
{
return(versionInfo);
}
}
return(null);
}
/// <summary>Build 2D matrix of QR Code from "dataBits" with "ecLevel", "version" and "getMaskPattern".</summary>
/// <remarks>
/// Build 2D matrix of QR Code from "dataBits" with "ecLevel", "version" and "getMaskPattern". On
/// success, store the result in "matrix".
/// </remarks>
/// <param name="dataBits">BitVector containing the databits</param>
/// <param name="ecLevel">Error correction level of the QR code (L,M,Q,H)</param>
/// <param name="version">Version of the QR code, [1 .. 40]</param>
/// <param name="maskPattern">masking pattern</param>
/// <param name="matrix">Bytematrix in which the output will be stored</param>
public static void BuildMatrix(BitVector dataBits, ErrorCorrectionLevel ecLevel, int version, int maskPattern
, ByteMatrix matrix)
{
ClearMatrix(matrix);
EmbedBasicPatterns(version, matrix);
// Type information appear with any version.
EmbedTypeInfo(ecLevel, maskPattern, matrix);
// Version info appear if version >= 7.
MaybeEmbedVersionInfo(version, matrix);
// Data should be embedded at end.
EmbedDataBits(dataBits, maskPattern, matrix);
}
private DecoderResult decode(BitMatrixParser parser, IDictionary <DecodeHintType, object> hints)
{
Version version = parser.readVersion();
if (version == null)
{
return(null);
}
var formatinfo = parser.readFormatInformation();
if (formatinfo == null)
{
return(null);
}
ErrorCorrectionLevel ecLevel = formatinfo.ErrorCorrectionLevel;
// Read codewords
byte[] codewords = parser.readCodewords();
if (codewords == null)
{
return(null);
}
// Separate into data blocks
DataBlock[] dataBlocks = DataBlock.getDataBlocks(codewords, version, ecLevel);
// Count total number of data bytes
int totalBytes = 0;
foreach (var dataBlock in dataBlocks)
{
totalBytes += dataBlock.NumDataCodewords;
}
byte[] resultBytes = new byte[totalBytes];
int resultOffset = 0;
// Error-correct and copy data blocks together into a stream of bytes
foreach (var dataBlock in dataBlocks)
{
byte[] codewordBytes = dataBlock.Codewords;
int numDataCodewords = dataBlock.NumDataCodewords;
if (!correctErrors(codewordBytes, numDataCodewords))
{
return(null);
}
for (int i = 0; i < numDataCodewords; i++)
{
resultBytes[resultOffset++] = codewordBytes[i];
}
}
// Decode the contents of that stream of bytes
return(DecodedBitStreamParser.decode(resultBytes, version, ecLevel, hints));
}
/// <summary>
/// Use number of data bits(header + eci header + data bits from EncoderBase) to search for proper version to use
/// between min and max boundary.
/// Boundary define by DynamicSearchIndicator method.
/// </summary>
private static int BinarySearch(int numDataBits, ErrorCorrectionLevel level, int lowerVersionNum, int higherVersionNum)
{
//int middleVersionNumber;
//while (lowerVersionNum <= higherVersionNum)
//{
// middleVersionNumber = (lowerVersionNum + higherVersionNum) / 2;
// QRCodeVersion version = VersionTable.GetVersionByNum(middleVersionNumber);
// int numECCodewords = version.GetECBlocksByLevel(level).NumErrorCorrectionCodewards;
// int dataCodewords = version.TotalCodewords - numECCodewords;
// if (dataCodewords << 3 == numDataBits)
// return middleVersionNumber;
// if (dataCodewords << 3 > numDataBits)
// {
// higherVersionNum = middleVersionNumber - 1;
// }
// else
// {
// lowerVersionNum = middleVersionNumber + 1;
// }
//}
//return 4;
int middleVersionNumber;
while (lowerVersionNum <= higherVersionNum)
{
middleVersionNumber = (lowerVersionNum + higherVersionNum) / 2;
QRCodeVersion version = VersionTable.GetVersionByNum(middleVersionNumber);
int numECCodewords = version.GetECBlocksByLevel(level).NumErrorCorrectionCodewards;
int dataCodewords = version.TotalCodewords - numECCodewords;
if (dataCodewords << 3 == numDataBits)
{
return(middleVersionNumber);
}
if (dataCodewords << 3 > numDataBits)
{
higherVersionNum = middleVersionNumber - 1;
}
else
{
lowerVersionNum = middleVersionNumber + 1;
}
}
return(lowerVersionNum);
}
private FormatInformation(int formatInfo)
{
//ISO/IEC 18004:2006(E) 6.9 Format information
//Symbol number 0: 000
//Data mask pattern reference: 11
//Data bits (symbol number, data mask pattern reference): 00011
var p = SYMBOL_NUMBERS_INFO[(formatInfo >> 2) & 0x07];
errorCorrectionLevel = p.Value;
version = Version.getVersionForNumber(p.Key);
dataMask = (sbyte)(formatInfo & 0x03);
}
public ErrorCorrectionInfo GetCorrectionInfo(ErrorCorrectionLevel level)
{
switch (level)
{
case ErrorCorrectionLevel.L: return L;
case ErrorCorrectionLevel.M: return M;
case ErrorCorrectionLevel.Q: return Q;
case ErrorCorrectionLevel.H: return H;
default:
Debug.Fail("Unknown value.");
throw new ArgumentOutOfRangeException();
}
}
public QRCode()
{
mode = null;
ecLevel = null;
version = -1;
matrixWidth = -1;
maskPattern = -1;
numTotalBytes = -1;
numDataBytes = -1;
numECBytes = -1;
numRSBlocks = -1;
matrix = null;
}
private static BitMatrix ProcessEncodationResult(EncodationStruct encodeStruct, ErrorCorrectionLevel errorLevel)
{
BitList codewords = ECGenerator.FillECCodewords(encodeStruct.DataCodewords, encodeStruct.VersionDetail);
TriStateMatrix triMatrix = new TriStateMatrix(encodeStruct.VersionDetail.MatrixWidth);
PositioninngPatternBuilder.EmbedBasicPatterns(encodeStruct.VersionDetail.Version, triMatrix);
triMatrix.EmbedVersionInformation(encodeStruct.VersionDetail.Version);
triMatrix.EmbedFormatInformation(errorLevel, new Pattern0());
triMatrix.TryEmbedCodewords(codewords);
return triMatrix.GetLowestPenaltyMatrix(errorLevel);
}
public FormatInformation(int mask, ErrorCorrectionLevel errorCorrectionLevel)
{
if (0 <= mask && mask <= 7)
{
Mask = mask;
MaskPattern = GetMaskPattern(mask);
ErrorCorrectionLevel = errorCorrectionLevel;
}
else
{
throw new Exception($"Attempt to create FormatInformation with mask not in the range [{MinMask}:{MaxMask}]. Given mask: {mask}");
}
}
public QrCreator(ArgsModel args, ErrorCorrectionLevel level = ErrorCorrectionLevel.H, int Width = 500, int Height = 500)
{
switch (args.LoadMode)
{
case LoadMode.Text:
CreateFromContent(args.Content, level, Width, Height);
break;
case LoadMode.Image:
CreateFromImageFile(args.Content, level, Width, Height);
break;
}
}
/// <summary>
/// Parse QueryString that define the QR code properties
/// </summary>
/// <param name="request">HttpRequest containing HTTP GET data</param>
/// <returns>A QR code descriptor object</returns>
public static CodeDescriptor Init(ErrorCorrectionLevel level, string content, QuietZoneModules qzModules, int moduleSize)
{
var cp = new CodeDescriptor();
//// Error correction level
cp.Ecl = level;
//// Code content to encode
cp.Content = content;
//// Size of the quiet zone
cp.QuietZones = qzModules;
//// Module size
cp.ModuleSize = moduleSize;
return(cp);
}
/// <summary>
/// Parse QueryString that define the QR code properties
/// </summary>
/// <param name="request">HttpRequest containing HTTP GET data</param>
/// <returns>A QR code descriptor object</returns>
public static CodeDescriptor Init(ErrorCorrectionLevel level, string content, QuietZoneModules qzModules, int moduleSize)
{
var cp = new CodeDescriptor();
//// Error correction level
cp.Ecl = level;
//// Code content to encode
cp.Content = content;
//// Size of the quiet zone
cp.QuietZones = qzModules;
//// Module size
cp.ModuleSize = moduleSize;
return cp;
}
internal static EncodationStruct Encode(string content, ErrorCorrectionLevel ecLevel)
{
RecognitionStruct recognitionResult = InputRecognise.Recognise(content);
EncoderBase encoderBase = CreateEncoder(recognitionResult.EncodingName);
BitList encodeContent = encoderBase.GetDataBits(content);
int encodeContentLength = encodeContent.Count;
VersionControlStruct vcStruct =
VersionControl.InitialSetup(encodeContentLength, ecLevel, recognitionResult.EncodingName);
BitList dataCodewords = new BitList();
// Eci header
if (vcStruct.IsContainECI && !(vcStruct.ECIHeader is null))
{
dataCodewords.Add(vcStruct.ECIHeader);
}
// Header
dataCodewords.Add(encoderBase.GetModeIndicator());
int numLetter = encodeContentLength >> 3;
dataCodewords.Add(encoderBase.GetCharCountIndicator(numLetter, vcStruct.VersionDetail.Version));
// Data
dataCodewords.Add(encodeContent);
// Terminator Padding
dataCodewords.TerminateBites(dataCodewords.Count, vcStruct.VersionDetail.NumDataBytes);
int dataCodewordsCount = dataCodewords.Count;
if ((dataCodewordsCount & 0x7) != 0)
{
throw new ArgumentException($"{nameof(dataCodewords)} is not byte sized.");
}
else if (dataCodewordsCount >> 3 != vcStruct.VersionDetail.NumDataBytes)
{
throw new ArgumentException($"{nameof(dataCodewords)} num of bytes not equal to {nameof(vcStruct.VersionDetail.NumDataBytes)} for current version");
}
var encStruct = new EncodationStruct(vcStruct)
{
DataCodewords = dataCodewords
};
return(encStruct);
}
//According Table 25 — Error correction level indicators
//Using these bits as enum values would destroy their order which currently corresponds to error correction strength.
internal static int GetErrorCorrectionIndicatorBits(ErrorCorrectionLevel errorLevel)
{
//L 01
//M 00
//Q 11
//H 10
return(errorLevel switch
{
ErrorCorrectionLevel.H => 0x02,
ErrorCorrectionLevel.L => 0x01,
ErrorCorrectionLevel.M => 0x00,
ErrorCorrectionLevel.Q => 0x03,
_ => throw new ArgumentException($"Unsupported error correction level [{errorLevel}]", nameof(errorLevel))
});
/// <summary>
/// Initializes a new instance of the <see cref="QrConfiguration"/> class.
/// </summary>
/// <param name="qrMode">Encoding mode for the message.</param>
/// <param name="ecc">Error correction level.</param>
/// <param name="version">QR code version. From 1 to 40 inclusive.</param>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="version"/> is less than 1.<br/>
/// -or-<br/>
/// <paramref name="version"/> is greater than 40.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="qrMode"/> is invalid.<br/>
/// -or-<br/>
/// <paramref name="ecc"/> is invalid.
/// </exception>
/// <example>
/// <code>
/// var qrConfig = new QrConfiguration(QrMode.Numeric, ErrorCorrectionLevel.Medium, 30);
/// </code>
/// </example>
/// <since_tizen> 4 </since_tizen>
public QrConfiguration(QrMode qrMode, ErrorCorrectionLevel ecc, int version)
{
if (version < 1 || version > 40)
{
throw new ArgumentOutOfRangeException(nameof(version), version,
"Valid version range is 1 to 40 inclusive.");
}
ValidationUtil.ValidateEnum(typeof(QrMode), qrMode, nameof(qrMode));
ValidationUtil.ValidateEnum(typeof(ErrorCorrectionLevel), ecc, nameof(ecc));
Mode = qrMode;
ErrorCorrectionLevel = ecc;
Version = version;
}
private static BitMatrix ProcessEncodationResult(EncodationStruct encodeStruct, ErrorCorrectionLevel errorLevel)
{
BitList codewords = ECGenerator.FillECCodewords(encodeStruct.DataCodewords, encodeStruct.VersionDetail);
TriStateMatrix triMatrix = new(encodeStruct.VersionDetail.MatrixWidth);
PositioningPatternBuilder.EmbedBasicPatterns(encodeStruct.VersionDetail.Version, triMatrix);
triMatrix.EmbedVersionInformation(encodeStruct.VersionDetail.Version);
triMatrix.EmbedFormatInformation(errorLevel, new Pattern0());
triMatrix.TryEmbedCodewords(codewords);
return(triMatrix.GetLowestPenaltyMatrix(errorLevel));
}
public static IBarcode Encode(string content, ErrorCorrectionLevel errorCorrectionLevel, Encoding encoding)
{
InternalEncoderBase encoder = GetEncoder(encoding);
(BitList bits, VersionInfo versionInfo) = encoder.Encode(content, errorCorrectionLevel);
var blocks = BlockList.SplitToBlocks(new Queue <byte>(bits.IterateBytes()), versionInfo);
byte[] data = blocks.Interleave(versionInfo);
QrCode result = Render(data, versionInfo);
result.Content = content;
return(result);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public com.google.zxing.common.BitMatrix encode(String contents, com.google.zxing.BarcodeFormat format, int width, int height, java.util.Map<com.google.zxing.EncodeHintType,?> hints) throws com.google.zxing.WriterException
public BitMatrix encode(string contents, BarcodeFormat format, int width, int height, IDictionary <EncodeHintType, object> hints)
{
if (contents.Length == 0)
{
throw new System.ArgumentException("Found empty contents");
}
if (format != BarcodeFormat.QR_CODE)
{
throw new System.ArgumentException("Can only encode QR_CODE, but got " + format);
}
if (width < 0 || height < 0)
{
throw new System.ArgumentException("Requested dimensions are too small: " + width + 'x' + height);
}
ErrorCorrectionLevel errorCorrectionLevel = ErrorCorrectionLevel.L;
int quietZone = QUIET_ZONE_SIZE;
if (hints != null)
{
//ErrorCorrectionLevel requestedECLevel = (ErrorCorrectionLevel) hints[EncodeHintType.ERROR_CORRECTION];
ErrorCorrectionLevel requestedECLevel = null;
if (hints.ContainsKey(EncodeHintType.ERROR_CORRECTION))
{
requestedECLevel = (ErrorCorrectionLevel)hints[EncodeHintType.ERROR_CORRECTION];
}
if (requestedECLevel != null)
{
errorCorrectionLevel = requestedECLevel;
}
//int? quietZoneInt = (int?) hints[EncodeHintType.MARGIN];
int?quietZoneInt = null;
if (hints.ContainsKey(EncodeHintType.MARGIN))
{
quietZoneInt = (int?)hints[EncodeHintType.MARGIN];
}
if (quietZoneInt != null)
{
quietZone = (int)quietZoneInt;
}
}
QRCode code = Encoder.encode(contents, errorCorrectionLevel, hints);
return(renderResult(code, width, height, quietZone));
}
/// <summary>
/// 将字符串转换二维码图片
/// </summary>
/// <param name="self"></param>
/// <param name="errLevel"></param>
/// <returns></returns>
public static QrCode ToQrCode(this string self, ErrorCorrectionLevel errLevel = ErrorCorrectionLevel.M)
{
if (self.NullEmpty())
{
return(null);
}
QrEncoder qrEncoder = new QrEncoder(ErrorCorrectionLevel.M);
//QrCode qrCode = qrEncoder.Encode(self);
QrCode qrCode = new QrCode();
qrEncoder.TryEncode(self, out qrCode);
return(qrCode);
//Renderer renderer = new Renderer(5, Brushes.Black, Brushes.White);
//renderer.CreateImageFile(qrCode.Matrix, @"c:\temp\HelloWorld.png", ImageFormat.Png);
}
/// <summary>
/// Encodes the specified content.
/// </summary>
/// <param name="content">The content.</param>
/// <param name="errorLevel">The error level.</param>
/// <returns></returns>
/// <remarks></remarks>
internal static BitMatrix Encode(string content, ErrorCorrectionLevel errorLevel)
{
EncodationStruct encodeStruct = DataEncode.Encode(content, errorLevel);
BitList codewords = ECGenerator.FillECCodewords(encodeStruct.DataCodewords, encodeStruct.VersionDetail);
var triMatrix = new TriStateMatrix(encodeStruct.VersionDetail.MatrixWidth);
PositioninngPatternBuilder.EmbedBasicPatterns(encodeStruct.VersionDetail.Version, triMatrix);
triMatrix.EmbedVersionInformation(encodeStruct.VersionDetail.Version);
triMatrix.EmbedFormatInformation(errorLevel, new Pattern0());
triMatrix.TryEmbedCodewords(codewords);
return triMatrix.GetLowestPenaltyMatrix(errorLevel);
}
// Build 2D matrix of QR Code from "dataBits" with "ecLevel", "version" and "getMaskPattern". On
// success, store the result in "matrix" and return true.
public static void buildMatrix(BitVector dataBits, ErrorCorrectionLevel ecLevel, int version, int maskPattern, ByteMatrix matrix)
{
try{
clearMatrix(matrix);
embedBasicPatterns(version, matrix);
// Type information appear with any version.
embedTypeInfo(ecLevel, maskPattern, matrix);
// Version info appear if version >= 7.
maybeEmbedVersionInfo(version, matrix);
// Data should be embedded at end.
embedDataBits(dataBits, maskPattern, matrix);
}catch (Exception e) {
throw new WriterException(e.Message);
}
}
/// <summary>
/// Initializes a new instance of a <see cref="GoogleQrCodeProvider"/> with the specified
/// <see cref="ErrorCorrectionLevel"/>, <see cref="MarginRows"/> and
/// <see cref="RemoteCertificateValidationCallback"/>.
/// </summary>
/// <param name="errorCorrectionLevel">The <see cref="ErrorCorrectionLevel"/> to use when generating QR codes.</param>
/// <param name="marginRows">The width of the white border around the data portion of the code.</param>
/// <param name="remoteCertificateValidationCallback">
/// The <see cref="RemoteCertificateValidationCallback"/> to use when generating QR codes.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown when an invalid <see cref="ErrorCorrectionLevel"/> is specified or marginRows is less than 0.
/// </exception>
public GoogleQrCodeProvider(ErrorCorrectionLevel errorCorrectionLevel, int marginRows, RemoteCertificateValidationCallback remoteCertificateValidationCallback)
: base(baseuri, remoteCertificateValidationCallback)
{
if (!Enum.IsDefined(typeof(ErrorCorrectionLevel), errorCorrectionLevel))
{
throw new ArgumentOutOfRangeException("errorCorrectionLevel");
}
this.ErrorCorrectionLevel = errorCorrectionLevel;
if (marginRows < 0)
{
throw new ArgumentOutOfRangeException("marginRows");
}
this.MarginRows = marginRows;
}
public void testForBits()
{
Assert.AreEqual(ErrorCorrectionLevel.M, ErrorCorrectionLevel.forBits(0));
Assert.AreEqual(ErrorCorrectionLevel.L, ErrorCorrectionLevel.forBits(1));
Assert.AreEqual(ErrorCorrectionLevel.H, ErrorCorrectionLevel.forBits(2));
Assert.AreEqual(ErrorCorrectionLevel.Q, ErrorCorrectionLevel.forBits(3));
try
{
ErrorCorrectionLevel.forBits(4);
throw new AssertionException("Should have thrown an exception");
}
catch (ArgumentException)
{
// good
}
}
/// <summary>
/// Get Error Correction Blocks by level
/// </summary>
/// <param name="ECLevel">The EC level.</param>
/// <returns></returns>
/// <remarks></remarks>
//[method
internal ErrorCorrectionBlocks GetECBlocksByLevel(ErrorCorrectionLevel ECLevel)
{
switch (ECLevel)
{
case ErrorCorrectionLevel.L:
return m_ECBlocks[0];
case ErrorCorrectionLevel.M:
return m_ECBlocks[1];
case ErrorCorrectionLevel.Q:
return m_ECBlocks[2];
case ErrorCorrectionLevel.H:
return m_ECBlocks[3];
default:
throw new ArgumentOutOfRangeException("Invalide ErrorCorrectionLevel");
}
}
/// <summary>
/// Zpl QrCode
/// </summary>
/// <param name="content"></param>
/// <param name="positionX"></param>
/// <param name="positionY"></param>
/// <param name="model">1 (original) and 2 (enhanced – recommended)</param>
/// <param name="magnificationFactor">Size of the QR code, 1 on 150 dpi printers, 2 on 200 dpi printers, 3 on 300 dpi printers, 6 on 600 dpi printers</param>
/// <param name="errorCorrectionLevel"></param>
/// <param name="maskValue">0-7, (default: 7)</param>
public ZplQrCode(
string content,
int positionX,
int positionY,
int model = 2,
int magnificationFactor = 2,
ErrorCorrectionLevel errorCorrectionLevel = ErrorCorrectionLevel.HighReliability,
int maskValue = 7)
: base(positionX, positionY)
{
Content = content;
Model = model;
MagnificationFactor = magnificationFactor;
ErrorCorrectionLevel = errorCorrectionLevel;
MaskValue = maskValue;
}
/// <summary>
/// Encodes the specified content.
/// </summary>
/// <param name="content">The content.</param>
/// <param name="errorLevel">The error level.</param>
/// <returns></returns>
/// <remarks></remarks>
internal static BitMatrix Encode(string content, ErrorCorrectionLevel errorLevel)
{
EncodationStruct encodeStruct = DataEncode.Encode(content, errorLevel);
BitList codewords = ECGenerator.FillECCodewords(encodeStruct.DataCodewords, encodeStruct.VersionDetail);
var triMatrix = new TriStateMatrix(encodeStruct.VersionDetail.MatrixWidth);
PositioninngPatternBuilder.EmbedBasicPatterns(encodeStruct.VersionDetail.Version, triMatrix);
triMatrix.EmbedVersionInformation(encodeStruct.VersionDetail.Version);
triMatrix.EmbedFormatInformation(errorLevel, new Pattern0());
triMatrix.TryEmbedCodewords(codewords);
return(triMatrix.GetLowestPenaltyMatrix(errorLevel));
}
public static BarcodeWriterPixelData createBarcodeWriterPixelData(ErrorCorrectionLevel correction, int size = 30, int margin = 0)
{
var qrCodeWriter = new BarcodeWriterPixelData
{
Format = BarcodeFormat.QR_CODE,
Options = new QrCodeEncodingOptions
{
Height = size,
Width = size,
Margin = margin,
ErrorCorrection = correction
},
};
return(qrCodeWriter);
}
private static uint GetBinaryIndicatorForErrorCorrectionLevel(ErrorCorrectionLevel level)
{
// See ISO/IEC 18004:2006(E), Sec. 6.9.1, Table 12
switch (level)
{
case ErrorCorrectionLevel.L: return(1);
case ErrorCorrectionLevel.M: return(0);
case ErrorCorrectionLevel.Q: return(3);
case ErrorCorrectionLevel.H: return(2);
}
throw new InvalidOperationException();
}
internal static EncodationStruct Encode(string content, ErrorCorrectionLevel ecLevel)
{
RecognitionStruct recognitionResult = InputRecognise.Recognise(content);
EncoderBase encoderBase = CreateEncoder(recognitionResult.EncodingName);
BitList encodeContent = encoderBase.GetDataBits(content);
int encodeContentLength = encodeContent.Count;
VersionControlStruct vcStruct =
VersionControl.InitialSetup(encodeContentLength, ecLevel, recognitionResult.EncodingName);
BitList dataCodewords = new();
// Eci header
if (vcStruct.IsContainECI && vcStruct.ECIHeader is { })
public ErrorCorrectionInfo GetCorrectionInfo(ErrorCorrectionLevel level)
{
switch (level)
{
case ErrorCorrectionLevel.L: return(L);
case ErrorCorrectionLevel.M: return(M);
case ErrorCorrectionLevel.Q: return(Q);
case ErrorCorrectionLevel.H: return(H);
default:
Debug.Fail("Unknown value.");
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// 生成二维码
/// </summary>
/// <param name="strContent"></param>
/// <returns></returns>
public MemoryStream GetQRCode(string strContent)
{
MemoryStream ms = new MemoryStream();
ErrorCorrectionLevel Ecl = ErrorCorrectionLevel.M; //误差校正水平
string Content = strContent; //待编码内容
QuietZoneModules QuietZones = QuietZoneModules.Two; //空白区域
int ModuleSize = 12; //大小
var encoder = new QrEncoder(Ecl);
QrCode qr;
if (encoder.TryEncode(Content, out qr))//对内容进行编码，并保存生成的矩阵
{
var render = new GraphicsRenderer(new FixedModuleSize(ModuleSize, QuietZones));
render.WriteToStream(qr.Matrix, ImageFormat.Png, ms);
}
return(ms);
}
// Encode "bytes" with the error correction level "getECLevel". The encoding mode will be chosen
// internally by chooseMode(). On success, store the result in "qrCode" and return true.
// We recommend you to use QRCode.EC_LEVEL_L (the lowest level) for
// "getECLevel" since our primary use is to show QR code on desktop screens. We don't need very
// strong error correction for this purpose.
//
// Note that there is no way to encode bytes in MODE_KANJI. We might want to add EncodeWithMode()
// with which clients can specify the encoding mode. For now, we don't need the functionality.
public static void encode(String content, ErrorCorrectionLevel ecLevel, QRCode qrCode)
{
// Step 1: Choose the mode (encoding).
Mode mode = chooseMode(content);
// Step 2: Append "bytes" into "dataBits" in appropriate encoding.
BitVector dataBits = new BitVector();
appendBytes(content, mode, dataBits);
// Step 3: Initialize QR code that can contain "dataBits".
int numInputBytes = dataBits.sizeInBytes();
initQRCode(numInputBytes, ecLevel, mode, qrCode);
// Step 4: Build another bit vector that contains header and data.
BitVector headerAndDataBits = new BitVector();
appendModeInfo(qrCode.getMode(), headerAndDataBits);
appendLengthInfo(content.Length, qrCode.getVersion(), qrCode.getMode(), headerAndDataBits);
headerAndDataBits.appendBitVector(dataBits);
// Step 5: Terminate the bits properly.
terminateBits(qrCode.getNumDataBytes(), headerAndDataBits);
// Step 6: Interleave data bits with error correction code.
BitVector finalBits = new BitVector();
interleaveWithECBytes(headerAndDataBits, qrCode.getNumTotalBytes(), qrCode.getNumDataBytes(),
qrCode.getNumRSBlocks(), finalBits);
// Step 7: Choose the mask pattern and set to "qrCode".
ByteMatrix matrix = new ByteMatrix(qrCode.getMatrixWidth(), qrCode.getMatrixWidth());
qrCode.setMaskPattern(chooseMaskPattern(finalBits, qrCode.getECLevel(), qrCode.getVersion(),
matrix));
// Step 8. Build the matrix and set it to "qrCode".
MatrixUtil.buildMatrix(finalBits, qrCode.getECLevel(), qrCode.getVersion(),
qrCode.getMaskPattern(), matrix);
qrCode.setMatrix(matrix);
// Step 9. Make sure we have a valid QR Code.
if (!qrCode.isValid())
{
throw new WriterException("Invalid QR code: " + qrCode.toString());
}
}
/// <summary>
/// RSブロック数を返します。
/// </summary>
/// <param name="ecLevel">誤り訂正レベル</param>
/// <param name="version">型番</param>
/// <param name="preceding">RSブロック前半部分は true を指定します。</param>
public static int GetTotalNumber(
ErrorCorrectionLevel ecLevel, int version, bool preceding)
{
int numDataCodewords = DataCodeword.GetTotalNumber(ecLevel, version);
int numRSBlocks = _totalNumbers[(int)ecLevel][version];
int numFolBlocks = numDataCodewords % numRSBlocks;
if (preceding)
{
return(numRSBlocks - numFolBlocks);
}
else
{
return(numFolBlocks);
}
}
internal static EncodationStruct Encode(IEnumerable <byte> content, ErrorCorrectionLevel eclevel)
{
EncoderBase encoderBase = CreateEncoder(QRCodeConstantVariable.DefaultEncoding);
BitList encodeContent = new BitList(content);
int encodeContentLength = encodeContent.Count;
VersionControlStruct vcStruct =
VersionControl.InitialSetup(encodeContentLength, eclevel, QRCodeConstantVariable.DefaultEncoding);
BitList dataCodewords = new BitList();
//Eci header
if (vcStruct.IsContainECI && !(vcStruct.ECIHeader is null))
{
dataCodewords.Add(vcStruct.ECIHeader);
}
//Header
dataCodewords.Add(encoderBase.GetModeIndicator());
int numLetter = encodeContentLength >> 3;
dataCodewords.Add(encoderBase.GetCharCountIndicator(numLetter, vcStruct.VersionDetail.Version));
//Data
dataCodewords.Add(encodeContent);
//Terminator Padding
dataCodewords.TerminateBites(dataCodewords.Count, vcStruct.VersionDetail.NumDataBytes);
int dataCodewordsCount = dataCodewords.Count;
if ((dataCodewordsCount & 0x7) != 0)
{
throw new ArgumentException("data codewords is not byte sized.");
}
else if (dataCodewordsCount >> 3 != vcStruct.VersionDetail.NumDataBytes)
{
throw new ArgumentException("datacodewords num of bytes not equal to NumDataBytes for current version");
}
var encStruct = new EncodationStruct(vcStruct)
{
DataCodewords = dataCodewords
};
return(encStruct);
}
public VersionInfo(
byte version,
ErrorCorrectionLevel errorCorrectionLevel,
byte errorCorrectionCodewordsPerBlock,
byte numberOfBlocksInGroup1,
byte dataCodewordsPerBlockInGroup1,
byte numberOfBlocksInGroup2,
byte dataCodewordsPerBlockInGroup2)
{
Version = version;
ErrorCorrectionLevel = errorCorrectionLevel;
ErrorCorrectionCodewordsPerBlock = errorCorrectionCodewordsPerBlock;
NumberOfBlocksInGroup1 = numberOfBlocksInGroup1;
DataCodewordsPerBlockInGroup1 = dataCodewordsPerBlockInGroup1;
NumberOfBlocksInGroup2 = numberOfBlocksInGroup2;
DataCodewordsPerBlockInGroup2 = dataCodewordsPerBlockInGroup2;
}
public void Test_against_reference_implementation(int numDataBits, Mode mode, ErrorCorrectionLevel level, string encodingName)
{
VersionControlStruct vcStruct = VersionControl.InitialSetup(numDataBits, mode, level, encodingName);
VersionCheckStatus checkStatus = VersionTest.VersionCheck(vcStruct.VersionDetail.Version, numDataBits, mode, level, encodingName);
switch(checkStatus)
{
case VersionCheckStatus.LargerThanExpect:
Assert.Fail("Version {0} size not enough", vcStruct.VersionDetail.Version);
break;
case VersionCheckStatus.SmallerThanExpect:
Assert.Fail("Version{0}'s size too big", vcStruct.VersionDetail.Version);
break;
default:
break;
}
}
/// <summary>
/// Determine which version to use
/// </summary>
/// <param name="dataBitsLength">Number of bits for encoded content</param>
/// <param name="mode">The mode.</param>
/// <param name="level">The level.</param>
/// <param name="encodingName">Encoding name for EightBitByte</param>
/// <returns>VersionDetail and ECI</returns>
/// <remarks></remarks>
internal static VersionControlStruct InitialSetup(int dataBitsLength, Mode mode, ErrorCorrectionLevel level,
string encodingName)
{
int totalDataBits = dataBitsLength;
bool containECI = false;
var eciHeader = new BitList();
//Check ECI header
if (mode == Mode.EightBitByte)
{
if (encodingName != DEFAULT_ENCODING && encodingName != QRCodeConstantVariable.UTF8Encoding)
{
var eciSet = new ECISet(ECISet.AppendOption.NameToValue);
int eciValue = eciSet.GetECIValueByName(encodingName);
totalDataBits += ECISet.NumOfECIHeaderBits(eciValue);
eciHeader = eciSet.GetECIHeader(encodingName);
containECI = true;
}
}
//Determine which version group it belong to
int searchGroup = DynamicSearchIndicator(totalDataBits, level, mode);
int[] charCountIndicator = CharCountIndicatorTable.GetCharCountIndicatorSet(mode);
totalDataBits += (NUM_BITS_MODE_INDICATOR + charCountIndicator[searchGroup]);
int lowerSearchBoundary = searchGroup == 0 ? 1 : (VERSION_GROUP[searchGroup - 1] + 1);
int higherSearchBoundary = VERSION_GROUP[searchGroup];
//Binary search to find proper version
int versionNum = BinarySearch(totalDataBits, level, lowerSearchBoundary, higherSearchBoundary);
VersionControlStruct vcStruct = FillVCStruct(versionNum, level, encodingName);
vcStruct.isContainECI = containECI;
vcStruct.ECIHeader = eciHeader;
return vcStruct;
}
public static BitmapImage getQrBitmap(string text, ErrorCorrectionLevel errorCorrection = ErrorCorrectionLevel.M)
{
QrCode qrCode;
QrEncoder qrEncoder = new QrEncoder(errorCorrection);
qrEncoder.TryEncode(text, out qrCode);
GraphicsRenderer gRenderer = new GraphicsRenderer(
new FixedModuleSize(2, QuietZoneModules.Two),
Brushes.Black, Brushes.White);
BitmapImage bi = new BitmapImage();
using (MemoryStream memoryStream = new MemoryStream())
{
gRenderer.WriteToStream(qrCode.Matrix, ImageFormat.Png, memoryStream);
bi.BeginInit();
bi.CacheOption = BitmapCacheOption.OnLoad;
bi.StreamSource = memoryStream;
bi.EndInit();
}
return bi;
}
internal static BitMatrix GetLowestPenaltyMatrix(this TriStateMatrix matrix, ErrorCorrectionLevel errorlevel)
{
PatternFactory patternFactory = new PatternFactory();
int score = int.MaxValue;
int tempScore;
TriStateMatrix result = new TriStateMatrix(matrix.Width);
TriStateMatrix triMatrix;
foreach(Pattern pattern in patternFactory.AllPatterns())
{
triMatrix = matrix.Apply(pattern, errorlevel);
tempScore = triMatrix.PenaltyScore();
if(tempScore < score)
{
score = tempScore;
result = triMatrix;
}
}
return result;
}
private static BitList GetFormatInfoBits(ErrorCorrectionLevel errorlevel, Pattern pattern)
{
int formatInfo = (int)pattern.MaskPatternType;
//Pattern bits length = 3
formatInfo |= GetErrorCorrectionIndicatorBits(errorlevel) << 3;
int bchCode = BCHCalculator.CalculateBCH(formatInfo, s_FormatInfoPoly);
//bchCode length = 10
formatInfo = (formatInfo << 10) | bchCode;
//xor maskPattern
formatInfo ^= s_FormatInfoMaskPattern;
BitList resultBits = new BitList();
resultBits.Add(formatInfo, 15);
if(resultBits.Count != 15)
throw new Exception("FormatInfoBits length is not 15");
else
return resultBits;
}
/// <summary>
/// Embed format information to tristatematrix.
/// Process combination of create info bits, BCH error correction bits calculation, embed towards matrix.
/// </summary>
/// <remarks>ISO/IEC 18004:2000 Chapter 8.9 Page 53</remarks>
internal static void EmbedFormatInformation(this TriStateMatrix triMatrix, ErrorCorrectionLevel errorlevel, Pattern pattern)
{
BitList formatInfo = GetFormatInfoBits(errorlevel, pattern);
int width = triMatrix.Width;
for(int index = 0; index < 15; index++)
{
MatrixPoint point = PointForInfo1(index);
bool bit = formatInfo[index];
triMatrix[point.X, point.Y, MatrixStatus.NoMask] = bit;
if(index < 7)
{
triMatrix[8, width - 1 - index, MatrixStatus.NoMask] = bit;
}
else
{
triMatrix[width - 8 + (index - 7), 8, MatrixStatus.NoMask] = bit;
}
}
}
/// <summary>
/// Encodes the specified content.
/// </summary>
/// <param name="content">The content.</param>
/// <param name="ecLevel">The ec level.</param>
/// <returns></returns>
/// <remarks></remarks>
internal static EncodationStruct Encode(string content, ErrorCorrectionLevel ecLevel)
{
RecognitionStruct recognitionResult = InputRecognise.Recognise(content);
EncoderBase encoderBase = CreateEncoder(recognitionResult.Mode, recognitionResult.EncodingName);
BitList encodeContent = encoderBase.GetDataBits(content);
int encodeContentLength = encodeContent.Count;
VersionControlStruct vcStruct =
VersionControl.InitialSetup(encodeContentLength, recognitionResult.Mode, ecLevel,
recognitionResult.EncodingName);
var dataCodewords = new BitList();
//Eci header
if (vcStruct.isContainECI && vcStruct.ECIHeader != null)
dataCodewords.Add(vcStruct.ECIHeader);
//Header
dataCodewords.Add(encoderBase.GetModeIndicator());
int numLetter = recognitionResult.Mode == Mode.EightBitByte ? encodeContentLength >> 3 : content.Length;
dataCodewords.Add(encoderBase.GetCharCountIndicator(numLetter, vcStruct.VersionDetail.Version));
//Data
dataCodewords.Add(encodeContent);
//Terminator Padding
dataCodewords.TerminateBites(dataCodewords.Count, vcStruct.VersionDetail.NumDataBytes);
int dataCodewordsCount = dataCodewords.Count;
if ((dataCodewordsCount & 0x7) != 0)
throw new ArgumentException("data codewords is not byte sized.");
else if (dataCodewordsCount >> 3 != vcStruct.VersionDetail.NumDataBytes)
{
throw new ArgumentException("datacodewords num of bytes not equal to NumDataBytes for current version");
}
var encStruct = new EncodationStruct(vcStruct);
encStruct.Mode = recognitionResult.Mode;
encStruct.DataCodewords = dataCodewords;
return encStruct;
}
/// <summary>
/// Méthode retournant un objet d'image Bitmap d'un code QR
/// </summary>
/// <param name="text">Le texte à encoder</param>
/// <param name="errorCorrection">Le niveau de correction d'erreur choisi. Détermine le pourcentage de la structure du codeQR est utilisé pour corriger les erreurs.</param>
/// <returns>Objet BitmapImage du codeQR</returns>
public static BitmapImage getQrBitmap(string text, ErrorCorrectionLevel errorCorrection = ErrorCorrectionLevel.M)
{
QrCode qrCode;
QrEncoder qrEncoder = new QrEncoder(errorCorrection);
//Peut techniquement échouer et le cas n'est pas géré.
qrEncoder.TryEncode(text, out qrCode);
//Détermine l'épaisseur des traits, la couleur de fond et la couleur du code QR.
GraphicsRenderer gRenderer = new GraphicsRenderer(
new FixedModuleSize(2, QuietZoneModules.Two),
Brushes.Black, Brushes.White);
BitmapImage bi = new BitmapImage();
using (MemoryStream memoryStream = new MemoryStream())
{
//Utilise les bytes du codeQR encodé qui se trouve dans l'objet qrCode dans un MemoryStream pour faire une BitmapImage.
gRenderer.WriteToStream(qrCode.Matrix, ImageFormat.Png, memoryStream);
bi.BeginInit();
bi.CacheOption = BitmapCacheOption.OnLoad;
bi.StreamSource = memoryStream;
bi.EndInit();
}
return bi;
}
//According Table 25 — Error correction level indicators
//Using this bits as enum values would destroy thir order which currently correspond to error correction strength.
internal static int GetErrorCorrectionIndicatorBits(ErrorCorrectionLevel errorLevel)
{
//L 01
//M 00
//Q 11
//H 10
switch (errorLevel)
{
case ErrorCorrectionLevel.H:
return 0x02;
case ErrorCorrectionLevel.L:
return 0x01;
case ErrorCorrectionLevel.M:
return 0x00;
case ErrorCorrectionLevel.Q:
return 0x03;
default:
throw new ArgumentException(string.Format("Unsupported error correction level [{0}]", errorLevel), "errorLevel");
}
}
internal static EncodationStruct Encode(IEnumerable<byte> content, ErrorCorrectionLevel eclevel)
{
EncoderBase encoderBase = CreateEncoder(Mode.EightBitByte, QRCodeConstantVariable.DefaultEncoding);
BitList encodeContent = new BitList(content);
int encodeContentLength = encodeContent.Count;
VersionControlStruct vcStruct =
VersionControl.InitialSetup(encodeContentLength, Mode.EightBitByte, eclevel, QRCodeConstantVariable.DefaultEncoding);
BitList dataCodewords = new BitList();
//Eci header
if (vcStruct.isContainECI && vcStruct.ECIHeader != null)
dataCodewords.Add(vcStruct.ECIHeader);
//Header
dataCodewords.Add(encoderBase.GetModeIndicator());
int numLetter = encodeContentLength >> 3;
dataCodewords.Add(encoderBase.GetCharCountIndicator(numLetter, vcStruct.VersionDetail.Version));
//Data
dataCodewords.Add(encodeContent);
//Terminator Padding
dataCodewords.TerminateBites(dataCodewords.Count, vcStruct.VersionDetail.NumDataBytes);
int dataCodewordsCount = dataCodewords.Count;
if ((dataCodewordsCount & 0x7) != 0)
throw new ArgumentException("data codewords is not byte sized.");
else if (dataCodewordsCount >> 3 != vcStruct.VersionDetail.NumDataBytes)
{
throw new ArgumentException("datacodewords num of bytes not equal to NumDataBytes for current version");
}
EncodationStruct encStruct = new EncodationStruct(vcStruct);
encStruct.Mode = Mode.EightBitByte;
encStruct.DataCodewords = dataCodewords;
return encStruct;
}
private static VersionControlStruct FillVCStruct(int versionNum, ErrorCorrectionLevel level, string encodingName)
{
if(versionNum < 1 || versionNum > 40)
{
throw new InvalidOperationException(string.Format("Unexpected version number: {0}", versionNum));
}
VersionControlStruct vcStruct = new VersionControlStruct();
int version = versionNum;
QRCodeVersion versionData = VersionTable.GetVersionByNum(versionNum);
int numTotalBytes = versionData.TotalCodewords;
ErrorCorrectionBlocks ecBlocks = versionData.GetECBlocksByLevel(level);
int numDataBytes = numTotalBytes - ecBlocks.NumErrorCorrectionCodewards;
int numECBlocks = ecBlocks.NumBlocks;
VersionDetail vcDetail = new VersionDetail(version, numTotalBytes, numDataBytes, numECBlocks);
vcStruct.VersionDetail = vcDetail;
return vcStruct;
}
public static Image GetQRCode(byte[] data, ErrorCorrectionLevel level = ErrorCorrectionLevel.M)
{
bool requires16BitLength = false;
int maxBytesInVersion9Code = QRErrorCorrections.GetQRVersionInfo(9).GetCorrectionInfo(level).TotalDataBytes;
if (maxBytesInVersion9Code - 2 < data.Length)
{
// This data requires a version 10 or higher code; will not fit in version 9 or lower.
// Version 10 and higher codes require 16-bit data lengths.
requires16BitLength = true;
}
StreamHelper sh = new StreamHelper();
sh.WriteNibble(0x04); // byte mode
if (requires16BitLength)
{
sh.WriteWord((ushort)data.Length);
}
else
{
sh.WriteByte((byte)data.Length);
}
sh.WriteBytes(new ArraySegment<byte>(data));
sh.WriteNibble(0x00); // terminator
byte[] binaryData = sh.ToArray();
int qrCodeVersion;
ErrorCorrectionLevel errorCorrectionLevel;
byte[] finalMessageSequence = QRErrorCorrections.GetMessageSequence(binaryData, level, out qrCodeVersion, out errorCorrectionLevel);
SymbolTemplate template = SymbolTemplate.CreateTemplate(qrCodeVersion);
template.ErrorCorrectionLevel = errorCorrectionLevel;
template.PopulateData(finalMessageSequence);
template.Complete();
return template.ToImage();
}
/// <summary>
/// Initializes a new instance of the <see cref="QRCodes"/> class.
/// </summary>
/// <param name="size">The chart size.</param>
/// <param name="text">The text to encode.</param>
/// <param name="encodingType">Type of the encoding.</param>
/// <param name="errorCorrection">Error correction level</param>
/// <param name="margin">Margin</param>
public QRCodes(ChartSize size, string text, EncodingType encodingType, ErrorCorrectionLevel errorCorrection, int margin)
: this(size, text, encodingType)
{
if ((errorCorrection != DefaultErrorCorrectionLevel) && (margin != DefaultMargin))
{
_options = new QROptions(errorCorrection, margin);
}
}
/// <summary>
/// QrEncoder with parameter ErrorCorrectionLevel.
/// </summary>
/// <param name="errorCorrectionLevel"></param>
public QrEncoder(ErrorCorrectionLevel errorCorrectionLevel)
{
ErrorCorrectionLevel = errorCorrectionLevel;
}
public void Test_against_reference_implementation(string inputString, ErrorCorrectionLevel eclevel, IEnumerable<bool> expected)
{
TestOneCase(inputString, eclevel, expected);
}
