Fix color balance rounding

Author: manuelbl

QrCodeGenerator/Penalty.cs

@@ -251,11 +251,12 @@ internal static int CalcColorBalance(BitMatrix modules)
 
             var size = modules.Size;
             var totalNumber = size * size;
-            var deviation = Math.Abs(darkModules - totalNumber / 2);
-            var step = totalNumber / 20;
-            // The integer division rounds down such that a proportion between 45% and 55%
-            // does not lead to any penalty points (as per specification).
-            var deviationSteps = deviation / step;
+            // The deviation in percent is |darkModules / totalNumber - 1/2| * 100, and a step is
+            // 5% of it. Scaled by 2 * totalNumber, the whole expression stays exact in integers:
+            // the numerator is |2 * darkModules - totalNumber| * 10, the denominator is
+            // totalNumber. The integer division rounds down such that a proportion between 45%
+            // and 55% does not lead to any penalty points (as per specification).
+            var deviationSteps = Math.Abs(2 * darkModules - totalNumber) * 10 / totalNumber;
             return 10 * deviationSteps;
         }
 

QrCodeGeneratorTest/PenaltyTest.cs

@@ -5,6 +5,7 @@
  * https://github.com/manuelbl/QrCodeGenerator
  */
 
+using System;
 using System.Diagnostics.CodeAnalysis;
 using Xunit;
 
@@ -321,6 +322,33 @@ public void CalcColorBalance(int size, double percent, int expectedPenalty)
             Assert.Equal(expectedPenalty, Penalty.CalcColorBalance(modules));
         }
 
+        [Theory, CombinatorialData]
+        public void CalcColorBalance_MatchesPercentageRule([CombinatorialValues(21, 29, 37, 65, 129, 177)] int size)
+        {
+            var totalNumber = size * size;
+
+            for (var darkModules = 0; darkModules <= totalNumber; darkModules += 1)
+            {
+                var percent = darkModules * 100.0 / totalNumber;
+                var expectedPenalty = 10 * (int)Math.Floor(Math.Abs(percent - 50.0) / 5.0);
+
+                Assert.Equal(expectedPenalty, Penalty.CalcColorBalance(WithDarkCount(size, darkModules)));
+            }
+        }
+
+        [Theory, CombinatorialData]
+        public void CalcColorBalance_IsSymmetricUnderInversion([CombinatorialValues(21, 29, 37, 65, 129, 177)] int size)
+        {
+            var totalNumber = size * size;
+
+            for (var darkModules = 0; darkModules <= totalNumber / 2; darkModules += 1)
+            {
+                var penalty = Penalty.CalcColorBalance(WithDarkCount(size, darkModules));
+
+                Assert.Equal(penalty, Penalty.CalcColorBalance(WithDarkCount(size, totalNumber - darkModules)));
+            }
+        }
+
         [Theory, CombinatorialData]
         public void CalcColorBalance_BasePenalty([CombinatorialValues(21, 29, 37, 65, 129, 177)]int size)
         {
@@ -439,6 +467,17 @@ public void CalcFinderPattern_BasePenalty([CombinatorialValues(21, 29, 37, 65, 1
             Assert.Equal(0, Penalty.CalcFinderPattern(modules));
         }
 
+        // Creates a matrix with exactly the given number of dark modules.
+        private static BitMatrix WithDarkCount(int size, int darkModules)
+        {
+            var result = new BitMatrix(size);
+            for (var i = 0; i < darkModules; i += 1)
+            {
+                result.Set(i % size, i / size, true);
+            }
+            return result;
+        }
+
         private static BitMatrix Fill(int size, double percent)
         {
             var result = new BitMatrix(size);