Uniform pattern for generating graphics

manuelbl · manuelbl · commit 644301d9ca06 · 2026-05-24T23:02:00.000+02:00
diff --git a/QrCodeGenerator/BmpBuilder.cs b/QrCodeGenerator/BmpBuilder.cs
@@ -10,22 +10,10 @@
 
 namespace Net.Codecrete.QrCodeGenerator
 {
-    internal class BmpBuilder
+    internal static class BmpBuilder
     {
-        internal BmpBuilder(int size, bool[,] modules)
-        {
-            _size = size;
-            _modules = modules;
-        }
-
-        private readonly int _size;
-
-        // The modules of this QR code (false = light, true = dark).
-        // Immutable after constructor finishes.
-        private readonly bool[,] _modules;
-
         [SuppressMessage("csharpsquid", "S3776")]
-        internal byte[] ToBmpBitmap(int border, int scale, int foreground, int background)
+        internal static byte[] ToImage(QrCode qrCode, int border, int scale, int foreground, int background)
         {
             if (scale < 1)
             {
@@ -37,7 +25,8 @@ internal byte[] ToBmpBitmap(int border, int scale, int foreground, int backgroun
                 throw new ArgumentOutOfRangeException(nameof(border), border, "Border must be non-negative.");
             }
 
-            var dim = (_size + 2 * border) * scale;
+            var size = qrCode.Size;
+            var dim = (size + 2 * border) * scale;
 
             if (dim > short.MaxValue)
             {
@@ -121,7 +110,7 @@ internal byte[] ToBmpBitmap(int border, int scale, int foreground, int backgroun
 
             if (border > 0)
             {
-                var scaledSize = _size * scale;
+                var scaledSize = size * scale;
 
                 for (i = 0; i < aligned; ++i)
                 {
@@ -144,7 +133,7 @@ internal byte[] ToBmpBitmap(int border, int scale, int foreground, int backgroun
                 }
             }
 
-            for (y = 0; y < _size; ++y)
+            for (y = 0; y < size; ++y)
             {
                 int j;
                 var yOffset = y * scale + scaledBorder;
@@ -162,13 +151,13 @@ internal byte[] ToBmpBitmap(int border, int scale, int foreground, int backgroun
                             continue;
                         }
 
-                        if (x < border || x >= _size + border)
+                        if (x < border || x >= size + border)
                         {
                             px |= (byte)(1 << (7 - j));
                             continue;
                         }
 
-                        px |= (byte)(_modules[(_size - y - 1), x - border] ? 0 : 1 << (7 - j));
+                        px |= (byte)(qrCode.GetModule(x - border, size - y - 1) ? 0 : 1 << (7 - j));
                     }
 
                     buf[62 + i + yOffset * aligned] = px;
diff --git a/QrCodeGenerator/MatrixEncoder.cs b/QrCodeGenerator/MatrixEncoder.cs
@@ -162,7 +162,7 @@ private static BitMatrix CreatePattern(int patternIndex, int version)
 
         // Ordered by mask-selection frequency (descending) so low-penalty patterns
         // set a tight lowestPenalty early, maximizing early-stop bailouts in
-        // Penalty.CalculatePenalty(). See QrCodeGeneratorProfiling/README.md
+        // Penalty.Calculate(). See QrCodeGeneratorProfiling/README.md
         // "Mask Pattern Selection".
         private static readonly int[] PatternEvaluationOrder = { 2, 3, 7, 4, 6, 5, 0, 1 };
 
@@ -193,8 +193,8 @@ private static int ApplyBestPattern(BitMatrix modules, int version, int ecc, Enc
                 scoringMatrix.Xor(mask);
 
                 var penalty = encodingInfo == null
-                    ? Penalty.CalculatePenalty(scoringMatrix, lowestPenalty)
-                    : Penalty.CalculatePenaltyFully(scoringMatrix, ref encodingInfo.Penalties[pattern]);
+                    ? Penalty.Calculate(scoringMatrix, lowestPenalty)
+                    : Penalty.CalculateFully(scoringMatrix, ref encodingInfo.Penalties[pattern]);
 
                 // undo pattern
                 scoringMatrix.Xor(mask);
diff --git a/QrCodeGenerator/Penalty.cs b/QrCodeGenerator/Penalty.cs
@@ -29,7 +29,7 @@ internal static class Penalty
         // some value >= lowestPenaltySoFar (the partial sum at the point of bailout).
         // Either way, comparing the result against lowestPenaltySoFar with strict
         // less-than yields the correct mask-selection decision.
-        internal static int CalculatePenalty(ScoringMatrix matrix, int lowestPenaltySoFar)
+        internal static int Calculate(ScoringMatrix matrix, int lowestPenaltySoFar)
         {
             // Ordered by mean penalty contribution (descending) for early-stop
             // effectiveness; see QrCodeGeneratorProfiling/README.md "Penalty Contribution".
@@ -63,7 +63,7 @@ internal static int CalculatePenalty(ScoringMatrix matrix, int lowestPenaltySoFa
         }
 
         // Calculates the total penalty score, fully evaluating all contributions and collecting the details in penaltyInfo.
-        internal static int CalculatePenaltyFully(ScoringMatrix matrix, ref PenaltyScore penaltyInfo)
+        internal static int CalculateFully(ScoringMatrix matrix, ref PenaltyScore penaltyInfo)
         {
             penaltyInfo.Blocks = Calc2By2Blocks(matrix.Rows);
             penaltyInfo.VerticalStreaks = CalcSameColor(matrix.Columns);
diff --git a/QrCodeGenerator/QrCode.cs b/QrCodeGenerator/QrCode.cs
@@ -387,7 +387,7 @@ public bool GetModule(int x, int y)
         /// <param name="background">The background color. Defaults to white.</param>
         public string ToSvgString(int border, string foreground = "#000000", string background = "#ffffff")
         {
-            return SvgBuilder.ToSvgString(ToRectangles(), Size, border, foreground, background);
+            return SvgBuilder.ToSvgString(this, border, foreground, background);
         }
 
         /// <summary>
@@ -413,7 +413,7 @@ public string ToSvgString(int border, string foreground = "#000000", string back
         /// <exception cref="ArgumentOutOfRangeException">Thrown if border is negative</exception>
         public string ToGraphicsPath(int border = 0)
         {
-            return SvgBuilder.ToGraphicsPath(ToRectangles(), border);
+            return SvgBuilder.ToGraphicsPath(this, border);
         }
 
         /// <summary>
@@ -461,7 +461,7 @@ public IReadOnlyList<QrRectangle> ToRectangles()
         /// <paramref name="scale"/> is less than 1 or the resulting image is wider than 32,768 pixels.</exception>
         public byte[] ToBmpBitmap(int border = 0, int scale = 1, int foreground = 0x000000, int background = 0xffffff)
         {
-            return AsBmpBuilder().ToBmpBitmap(border, scale, foreground, background);
+            return BmpBuilder.ToImage(this, border, scale, foreground, background);
         }
 
         /// <summary>
@@ -492,15 +492,6 @@ public static int RgbColor(byte red, byte green, byte blue)
         #endregion
 
 
-        #region Private helper methods
-
-        private BmpBuilder AsBmpBuilder()
-        {
-            return new BmpBuilder(Size, _modules.ToBoolArray());
-        }
-
-        #endregion
-
 
         #region Constants and tables
 
diff --git a/QrCodeGenerator/SvgBuilder.cs b/QrCodeGenerator/SvgBuilder.cs
@@ -18,23 +18,22 @@ namespace Net.Codecrete.QrCodeGenerator
     internal static class SvgBuilder
     {
         // Creates a complete SVG document for the given rectangles.
-        internal static string ToSvgString(IReadOnlyList<QrRectangle> rectangles, int size, int border,
-            string foreground, string background)
+        internal static string ToSvgString(QrCode qrCode, int border, string foreground, string background)
         {
             if (border < 0)
             {
                 throw new ArgumentOutOfRangeException(nameof(border), "Border must be non-negative");
             }
 
-            var dim = size + border * 2;
+            var dim = qrCode.Size + border * 2;
             var sb = new StringBuilder()
                 .Append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
                 .Append("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n")
                 .Append($"<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 {dim} {dim}\" stroke=\"none\">\n")
                 .Append($"\t<rect width=\"100%\" height=\"100%\" fill=\"{background}\"/>\n")
                 .Append("\t<path d=\"");
 
-            AppendPath(sb, rectangles, border);
+            AppendPath(sb, qrCode.ToRectangles(), border);
 
             return sb
                 .Append($"\" fill=\"{foreground}\"/>\n")
@@ -43,15 +42,15 @@ internal static string ToSvgString(IReadOnlyList<QrRectangle> rectangles, int si
         }
 
         // Creates an SVG/XAML graphics path for the given rectangles.
-        internal static string ToGraphicsPath(IReadOnlyList<QrRectangle> rectangles, int border)
+        internal static string ToGraphicsPath(QrCode qrCode, int border)
         {
             if (border < 0)
             {
                 throw new ArgumentOutOfRangeException(nameof(border), "Border must be non-negative");
             }
 
             var path = new StringBuilder();
-            AppendPath(path, rectangles, border);
+            AppendPath(path, qrCode.ToRectangles(), border);
             return path.ToString();
         }
 
diff --git a/QrCodeGeneratorTest/PenaltyTest.cs b/QrCodeGeneratorTest/PenaltyTest.cs
@@ -335,22 +335,22 @@ public void CalcColorBalance_BasePenalty([CombinatorialValues(21, 29, 37, 65, 12
         [InlineData(25, 0.4)]
         [InlineData(37, 0.55)]
         [InlineData(65, 0.5)]
-        public void CalculatePenalty_EarlyStopHonorsContract(int size, double fillPercent)
+        public void Calculate_EarlyStopHonorsContract(int size, double fillPercent)
         {
             var modules = Fill(size, fillPercent);
             var scoringMatrix = ScoringMatrix.From(modules);
 
             // Baseline: int.MaxValue threshold disables early-stop, so the function
             // runs to completion and returns the exact penalty.
-            var truePenalty = Penalty.CalculatePenalty(scoringMatrix, int.MaxValue);
+            var truePenalty = Penalty.Calculate(scoringMatrix, int.MaxValue);
 
             // Contract: for any threshold T, the returned value is either the exact
             // penalty (no bailout) or some partial sum >= T (bailout fired). Either
             // way, comparing the result against T with strict less-than yields the
             // same mask-selection decision as a full computation.
             for (var threshold = -10; threshold <= truePenalty + 50; threshold += 1)
             {
-                var result = Penalty.CalculatePenalty(scoringMatrix, threshold);
+                var result = Penalty.Calculate(scoringMatrix, threshold);
                 Assert.True(result == truePenalty || result >= threshold,
                     $"threshold={threshold}, result={result}, truePenalty={truePenalty}");
             }

Original file line number	Diff line number	Diff line change
`@@ -10,22 +10,10 @@`
`10`	`10`
`11`	`11`	`namespace Net.Codecrete.QrCodeGenerator`
`12`	`12`	`{`
`13`		`- internal class BmpBuilder`
	`13`	`+ internal static class BmpBuilder`
`14`	`14`	`{`
`15`		`- internal BmpBuilder(int size, bool[,] modules)`
`16`		`- {`
`17`		`- _size = size;`
`18`		`- _modules = modules;`
`19`		`- }`
`20`		`-`
`21`		`- private readonly int _size;`
`22`		`-`
`23`		`- // The modules of this QR code (false = light, true = dark).`
`24`		`- // Immutable after constructor finishes.`
`25`		`- private readonly bool[,] _modules;`
`26`		`-`
`27`	`15`	`[SuppressMessage("csharpsquid", "S3776")]`
`28`		`- internal byte[] ToBmpBitmap(int border, int scale, int foreground, int background)`
	`16`	`+ internal static byte[] ToImage(QrCode qrCode, int border, int scale, int foreground, int background)`
`29`	`17`	`{`
`30`	`18`	`if (scale < 1)`
`31`	`19`	`{`
`@@ -37,7 +25,8 @@ internal byte[] ToBmpBitmap(int border, int scale, int foreground, int backgroun`
`37`	`25`	`throw new ArgumentOutOfRangeException(nameof(border), border, "Border must be non-negative.");`
`38`	`26`	`}`
`39`	`27`
`40`		`- var dim = (_size + 2 * border) * scale;`
	`28`	`+ var size = qrCode.Size;`
	`29`	`+ var dim = (size + 2 * border) * scale;`
`41`	`30`
`42`	`31`	`if (dim > short.MaxValue)`
`43`	`32`	`{`
`@@ -121,7 +110,7 @@ internal byte[] ToBmpBitmap(int border, int scale, int foreground, int backgroun`
`121`	`110`
`122`	`111`	`if (border > 0)`
`123`	`112`	`{`
`124`		`- var scaledSize = _size * scale;`
	`113`	`+ var scaledSize = size * scale;`
`125`	`114`
`126`	`115`	`for (i = 0; i < aligned; ++i)`
`127`	`116`	`{`
`@@ -144,7 +133,7 @@ internal byte[] ToBmpBitmap(int border, int scale, int foreground, int backgroun`
`144`	`133`	`}`
`145`	`134`	`}`
`146`	`135`
`147`		`- for (y = 0; y < _size; ++y)`
	`136`	`+ for (y = 0; y < size; ++y)`
`148`	`137`	`{`
`149`	`138`	`int j;`
`150`	`139`	`var yOffset = y * scale + scaledBorder;`
`@@ -162,13 +151,13 @@ internal byte[] ToBmpBitmap(int border, int scale, int foreground, int backgroun`
`162`	`151`	`continue;`
`163`	`152`	`}`
`164`	`153`
`165`		`- if (x < border \|\| x >= _size + border)`
	`154`	`+ if (x < border \|\| x >= size + border)`
`166`	`155`	`{`
`167`	`156`	`px \|= (byte)(1 << (7 - j));`
`168`	`157`	`continue;`
`169`	`158`	`}`
`170`	`159`
`171`		`- px \|= (byte)(_modules[(_size - y - 1), x - border] ? 0 : 1 << (7 - j));`
	`160`	`+ px \|= (byte)(qrCode.GetModule(x - border, size - y - 1) ? 0 : 1 << (7 - j));`
`172`	`161`	`}`
`173`	`162`
`174`	`163`	`buf[62 + i + yOffset * aligned] = px;`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ internal static class Penalty`
`29`	`29`	`// some value >= lowestPenaltySoFar (the partial sum at the point of bailout).`
`30`	`30`	`// Either way, comparing the result against lowestPenaltySoFar with strict`
`31`	`31`	`// less-than yields the correct mask-selection decision.`
`32`		`- internal static int CalculatePenalty(ScoringMatrix matrix, int lowestPenaltySoFar)`
	`32`	`+ internal static int Calculate(ScoringMatrix matrix, int lowestPenaltySoFar)`
`33`	`33`	`{`
`34`	`34`	`// Ordered by mean penalty contribution (descending) for early-stop`
`35`	`35`	`// effectiveness; see QrCodeGeneratorProfiling/README.md "Penalty Contribution".`
`@@ -63,7 +63,7 @@ internal static int CalculatePenalty(ScoringMatrix matrix, int lowestPenaltySoFa`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`// Calculates the total penalty score, fully evaluating all contributions and collecting the details in penaltyInfo.`
`66`		`- internal static int CalculatePenaltyFully(ScoringMatrix matrix, ref PenaltyScore penaltyInfo)`
	`66`	`+ internal static int CalculateFully(ScoringMatrix matrix, ref PenaltyScore penaltyInfo)`
`67`	`67`	`{`
`68`	`68`	`penaltyInfo.Blocks = Calc2By2Blocks(matrix.Rows);`
`69`	`69`	`penaltyInfo.VerticalStreaks = CalcSameColor(matrix.Columns);`
Original file line number	Diff line number	Diff line change
`@@ -387,7 +387,7 @@ public bool GetModule(int x, int y)`
`387`	`387`	`/// <param name="background">The background color. Defaults to white.</param>`
`388`	`388`	`public string ToSvgString(int border, string foreground = "#000000", string background = "#ffffff")`
`389`	`389`	`{`
`390`		`- return SvgBuilder.ToSvgString(ToRectangles(), Size, border, foreground, background);`
	`390`	`+ return SvgBuilder.ToSvgString(this, border, foreground, background);`
`391`	`391`	`}`
`392`	`392`
`393`	`393`	`/// <summary>`
`@@ -413,7 +413,7 @@ public string ToSvgString(int border, string foreground = "#000000", string back`
`413`	`413`	`/// <exception cref="ArgumentOutOfRangeException">Thrown if border is negative</exception>`
`414`	`414`	`public string ToGraphicsPath(int border = 0)`
`415`	`415`	`{`
`416`		`- return SvgBuilder.ToGraphicsPath(ToRectangles(), border);`
	`416`	`+ return SvgBuilder.ToGraphicsPath(this, border);`
`417`	`417`	`}`
`418`	`418`
`419`	`419`	`/// <summary>`
`@@ -461,7 +461,7 @@ public IReadOnlyList<QrRectangle> ToRectangles()`
`461`	`461`	`/// <paramref name="scale"/> is less than 1 or the resulting image is wider than 32,768 pixels.</exception>`
`462`	`462`	`public byte[] ToBmpBitmap(int border = 0, int scale = 1, int foreground = 0x000000, int background = 0xffffff)`
`463`	`463`	`{`
`464`		`- return AsBmpBuilder().ToBmpBitmap(border, scale, foreground, background);`
	`464`	`+ return BmpBuilder.ToImage(this, border, scale, foreground, background);`
`465`	`465`	`}`
`466`	`466`
`467`	`467`	`/// <summary>`
`@@ -492,15 +492,6 @@ public static int RgbColor(byte red, byte green, byte blue)`
`492`	`492`	`#endregion`
`493`	`493`
`494`	`494`
`495`		`- #region Private helper methods`
`496`		`-`
`497`		`- private BmpBuilder AsBmpBuilder()`
`498`		`- {`
`499`		`- return new BmpBuilder(Size, _modules.ToBoolArray());`
`500`		`- }`
`501`		`-`
`502`		`- #endregion`
`503`		`-`
`504`	`495`
`505`	`496`	`#region Constants and tables`
`506`	`497`
Original file line number	Diff line number	Diff line change
`@@ -18,23 +18,22 @@ namespace Net.Codecrete.QrCodeGenerator`
`18`	`18`	`internal static class SvgBuilder`
`19`	`19`	`{`
`20`	`20`	`// Creates a complete SVG document for the given rectangles.`
`21`		`- internal static string ToSvgString(IReadOnlyList<QrRectangle> rectangles, int size, int border,`
`22`		`- string foreground, string background)`
	`21`	`+ internal static string ToSvgString(QrCode qrCode, int border, string foreground, string background)`
`23`	`22`	`{`
`24`	`23`	`if (border < 0)`
`25`	`24`	`{`
`26`	`25`	`throw new ArgumentOutOfRangeException(nameof(border), "Border must be non-negative");`
`27`	`26`	`}`
`28`	`27`
`29`		`- var dim = size + border * 2;`
	`28`	`+ var dim = qrCode.Size + border * 2;`
`30`	`29`	`var sb = new StringBuilder()`
`31`	`30`	`.Append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")`
`32`	`31`	`.Append("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n")`
`33`	`32`	`.Append($"<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 {dim} {dim}\" stroke=\"none\">\n")`
`34`	`33`	`.Append($"\t<rect width=\"100%\" height=\"100%\" fill=\"{background}\"/>\n")`
`35`	`34`	`.Append("\t<path d=\"");`
`36`	`35`
`37`		`- AppendPath(sb, rectangles, border);`
	`36`	`+ AppendPath(sb, qrCode.ToRectangles(), border);`
`38`	`37`
`39`	`38`	`return sb`
`40`	`39`	`.Append($"\" fill=\"{foreground}\"/>\n")`
`@@ -43,15 +42,15 @@ internal static string ToSvgString(IReadOnlyList<QrRectangle> rectangles, int si`
`43`	`42`	`}`
`44`	`43`
`45`	`44`	`// Creates an SVG/XAML graphics path for the given rectangles.`
`46`		`- internal static string ToGraphicsPath(IReadOnlyList<QrRectangle> rectangles, int border)`
	`45`	`+ internal static string ToGraphicsPath(QrCode qrCode, int border)`
`47`	`46`	`{`
`48`	`47`	`if (border < 0)`
`49`	`48`	`{`
`50`	`49`	`throw new ArgumentOutOfRangeException(nameof(border), "Border must be non-negative");`
`51`	`50`	`}`
`52`	`51`
`53`	`52`	`var path = new StringBuilder();`
`54`		`- AppendPath(path, rectangles, border);`
	`53`	`+ AppendPath(path, qrCode.ToRectangles(), border);`
`55`	`54`	`return path.ToString();`
`56`	`55`	`}`
`57`	`56`