internal Pattern CreateByType(MaskPatternType maskPatternType)
{
switch (maskPatternType)
{
case MaskPatternType.Type0:
return(new Pattern0());
case MaskPatternType.Type1:
return(new Pattern1());
case MaskPatternType.Type2:
return(new Pattern2());
case MaskPatternType.Type3:
return(new Pattern3());
case MaskPatternType.Type4:
return(new Pattern4());
case MaskPatternType.Type5:
return(new Pattern5());
case MaskPatternType.Type6:
return(new Pattern6());
case MaskPatternType.Type7:
return(new Pattern7());
default:
throw new NotSupportedException("This is impossible.");
}
}
private TestCaseData GenerateRandomTestCaseData(int version, MaskPatternType patternType)
{
int matrixSize = VersionDetail.Width(version);
ByteMatrix matrix = new ByteMatrix(matrixSize, matrixSize);
EmbedAlignmentPattern(matrix, version, patternType);
return new TestCaseData(version, patternType, matrix.ToBitMatrix()).SetName(string.Format(s_TestNameFormat, matrixSize, version));
}
internal Pattern CreateByType(MaskPatternType maskPatternType)
{
switch (maskPatternType)
{
case MaskPatternType.Type0:
return new Pattern0();
case MaskPatternType.Type1:
return new Pattern1();
case MaskPatternType.Type2:
return new Pattern2();
case MaskPatternType.Type3:
return new Pattern3();
case MaskPatternType.Type4:
return new Pattern4();
case MaskPatternType.Type5:
return new Pattern5();
case MaskPatternType.Type6:
return new Pattern6();
case MaskPatternType.Type7:
return new Pattern7();
}
throw new ArgumentException(string.Format("Usupported pattern type {0}", maskPatternType), "maskPatternType");
}
protected virtual TestCaseData GenerateRandomTestCaseData(int matrixSize, Random randomizer, MaskPatternType pattern, PenaltyRules rules)
{
ByteMatrix matrix;
BitMatrix bitmatrix = GetOriginal(matrixSize, randomizer, out matrix);
ApplyPattern(matrix, (int)pattern);
int expect;
switch(rules)
{
case PenaltyRules.Rule01:
expect = MaskUtil.applyMaskPenaltyRule1(matrix);
break;
case PenaltyRules.Rule02:
expect = MaskUtil.applyMaskPenaltyRule2(matrix);
break;
case PenaltyRules.Rule03:
expect = MaskUtil.applyMaskPenaltyRule3(matrix);
break;
case PenaltyRules.Rule04:
expect = MaskUtil.applyMaskPenaltyRule4(matrix);
break;
default:
throw new InvalidOperationException(string.Format("Unsupport Rules {0}", rules.ToString()));
}
BitMatrix input = matrix.ToBitMatrix();
return new TestCaseData(input, (int)rules, expect).SetName(string.Format(s_TestNameFormat, input.Width, rules.ToString(), expect));
}
internal Pattern CreateByType(MaskPatternType maskPatternType)
{
switch (maskPatternType)
{
case MaskPatternType.Type0:
return(new Pattern0());
case MaskPatternType.Type1:
return(new Pattern1());
case MaskPatternType.Type2:
return(new Pattern2());
case MaskPatternType.Type3:
return(new Pattern3());
case MaskPatternType.Type4:
return(new Pattern4());
case MaskPatternType.Type5:
return(new Pattern5());
case MaskPatternType.Type6:
return(new Pattern6());
case MaskPatternType.Type7:
return(new Pattern7());
}
throw new ArgumentException(string.Format("Usupported pattern type {0}", maskPatternType), "maskPatternType");
}
private TestCaseData GenerateRandomTestCaseData(int version, MaskPatternType patternType)
{
int matrixSize = VersionDetail.Width(version);
ByteMatrix matrix = new ByteMatrix(matrixSize, matrixSize);
EmbedAlignmentPattern(matrix, version, patternType);
return(new TestCaseData(version, patternType, matrix.ToBitMatrix()).SetName(string.Format(s_TestNameFormat, matrixSize, version)));
}
public void Test_against_DataSet(TriStateMatrix input, MaskPatternType patternType, BitMatrix expected)
{
Pattern pattern = new PatternFactory().CreateByType(patternType);
BitMatrix result = input.Apply(pattern, ErrorCorrectionLevel.H);
expected.AssertEquals(result);
}
public void Test_against_DataSet(TriStateMatrix input, MaskPatternType patternType, BitMatrix expected)
{
Pattern pattern = new PatternFactory().CreateByType(patternType);
BitMatrix result = input.Apply(pattern, ErrorCorrectionLevel.H);
expected.AssertEquals(result);
}
private void Test_One_Case(int version, MaskPatternType patternType, TriStateMatrix expected)
{
TriStateMatrix target = new TriStateMatrix(expected.Width);
PositioninngPatternBuilder.EmbedBasicPatterns(version, target);
PatternFactory pf = new PatternFactory();
Pattern pt = pf.CreateByType(patternType);
target.EmbedFormatInformation(ErrorCorrectionLevel.H, pt);
expected.AssertEquals(target);
}
/// <summary>
/// Encode string content to QrCode matrix
/// </summary>
/// <exception cref="InputOutOfBoundaryException">
/// This exception for string content is null, empty or too large</exception>
public QrCode Encode(string content, MaskPatternType PatternType = MaskPatternType.Type5)
{
if (string.IsNullOrEmpty(content))
{
throw new InputOutOfBoundaryException("Input should not be empty or null");
}
else
{
return(new QrCode(QRCodeEncode.Encode(content, ErrorCorrectionLevel, PatternType)));
}
}
private void Test_One_Case(int version, MaskPatternType patternType, TriStateMatrix expected)
{
TriStateMatrix target = new TriStateMatrix(expected.Width);
PositioninngPatternBuilder.EmbedBasicPatterns(version, target);
PatternFactory pf = new PatternFactory();
Pattern pt = pf.CreateByType(patternType);
target.EmbedFormatInformation(ErrorCorrectionLevel.H, pt);
expected.AssertEquals(target);
}
internal Pattern CreateByType(MaskPatternType maskPatternType)
{
return(maskPatternType switch
{
MaskPatternType.Type0 => new Pattern0(),
MaskPatternType.Type1 => new Pattern1(),
MaskPatternType.Type2 => new Pattern2(),
MaskPatternType.Type3 => new Pattern3(),
MaskPatternType.Type4 => new Pattern4(),
MaskPatternType.Type5 => new Pattern5(),
MaskPatternType.Type6 => new Pattern6(),
MaskPatternType.Type7 => new Pattern7(),
_ => throw new NotSupportedException("This should never happen.")
});
private static BitMatrix ProcessEncodationResult(EncodationStruct encodeStruct, ErrorCorrectionLevel errorLevel, MaskPatternType maskPatternType = MaskPatternType.Type5)
{
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());
Pattern pattern = new PatternFactory().CreateByType(maskPatternType);
triMatrix.EmbedFormatInformation(errorLevel, pattern);
triMatrix.TryEmbedCodewords(codewords);
return(triMatrix.GetLowestPenaltyMatrix(errorLevel, pattern));
}
protected virtual TestCaseData GenerateRandomTestCaseData(int matrixSize, Random randomizer, MaskPatternType pattern, PenaltyRules rules)
{
ByteMatrix matrix;
BitMatrix bitmatrix = GetOriginal(matrixSize, randomizer, out matrix);
ApplyPattern(matrix, (int)pattern);
int expect;
switch (rules)
{
case PenaltyRules.Rule01:
expect = MaskUtil.applyMaskPenaltyRule1(matrix);
break;
case PenaltyRules.Rule02:
expect = MaskUtil.applyMaskPenaltyRule2(matrix);
break;
case PenaltyRules.Rule03:
expect = MaskUtil.applyMaskPenaltyRule3(matrix);
break;
case PenaltyRules.Rule04:
expect = MaskUtil.applyMaskPenaltyRule4(matrix);
break;
default:
throw new InvalidOperationException(string.Format("Unsupport Rules {0}", rules.ToString()));
}
BitMatrix input = matrix.ToBitMatrix();
return(new TestCaseData(input, (int)rules, expect).SetName(string.Format(s_TestNameFormat, input.Width, rules.ToString(), expect)));
}
protected abstract TestCaseData GenerateRandomTestCaseData(int matrixSize, Random randomizer, MaskPatternType pattern);
private void EmbedAlignmentPattern(ByteMatrix matrix, int version, MaskPatternType patterntype)
{
matrix.Clear(-1);
MatrixUtil.embedBasicPatterns(version, matrix);
MatrixUtil.embedTypeInfo(ErrorCorrectionLevelInternal.H, (int)patterntype, matrix);
}
public void Test_against_DataSet(int version, MaskPatternType patternType, TriStateMatrix expected)
{
Test_One_Case(version, patternType, expected);
}
protected override NUnit.Framework.TestCaseData GenerateRandomTestCaseData(int matrixSize, System.Random randomizer, MaskPatternType pattern)
{
return(base.GenerateRandomTestCaseData(matrixSize, randomizer, pattern, PenaltyRules.Rule01));
}
public void Test_against_DataSet(int version, MaskPatternType patternType, TriStateMatrix expected)
{
Test_One_Case(version, patternType, expected);
}
public void Test_against_reference_implementation(int version, MaskPatternType patternType, TriStateMatrix expected)
{
Test_One_Case(version, patternType, expected);
}
protected abstract TestCaseData GenerateRandomTestCaseData(int matrixSize, Random randomizer, MaskPatternType pattern);
protected override NUnit.Framework.TestCaseData GenerateRandomTestCaseData(int matrixSize, System.Random randomizer, MaskPatternType pattern)
{
return base.GenerateRandomTestCaseData(matrixSize, randomizer, pattern, PenaltyRules.Rule02);
}
public void Test_against_reference_implementation(int version, MaskPatternType patternType, TriStateMatrix expected)
{
Test_One_Case(version, patternType, expected);
}
private void EmbedAlignmentPattern(ByteMatrix matrix, int version, MaskPatternType patterntype)
{
matrix.Clear(-1);
MatrixUtil.embedBasicPatterns(version, matrix);
MatrixUtil.embedTypeInfo(ErrorCorrectionLevelInternal.H, (int)patterntype, matrix);
}
internal static BitMatrix Encode(string content, ErrorCorrectionLevel errorLevel, MaskPatternType maskPatternType)
{
EncodationStruct encodeStruct = DataEncode.Encode(content, errorLevel);
return(ProcessEncodationResult(encodeStruct, errorLevel, maskPatternType));
}
