Support for PNG generation

Author: manuelbl

QrCodeGenerator/PngBuilder.cs

@@ -0,0 +1,259 @@
+/* 
+ * QR code generator library (.NET)
+ *
+ * Copyright (c) Manuel Bleichenbacher (MIT License)
+ * https://github.com/manuelbl/QrCodeGenerator
+ * 
+ */
+
+using System;
+using System.IO;
+using System.IO.Compression;
+
+namespace Net.Codecrete.QrCodeGenerator
+{
+    /// <summary>
+    /// Creates a PNG file from a given QR code.
+    /// </summary>
+    internal sealed class PngBuilder
+    {
+        private static readonly byte[] Signature = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
+        private static readonly uint[] CrcTable =
+        {
+            0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+            0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+            0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+            0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+        };
+
+        private static readonly byte[] IHDR = { 73, 72, 68, 82 };
+        private static readonly byte[] PLTE = { 80, 76, 84, 69 };
+        private static readonly byte[] IDAT = { 73, 68, 65, 84 };
+        private static readonly byte[] IEND = { 73, 69, 78, 68 };
+
+        /// <summary>
+        /// Creates a PNG image for the given QR code.
+        /// <para>
+        /// The PNG image uses indexed colors, 1 bit per pixel and a palette with entries for the foreground and background colors.
+        /// </para>
+        /// </summary>
+        /// <param name="qrCode">The QR code.</param>
+        /// <param name="border">The border width, as a factor of the module (QR code pixel) size.</param>
+        /// <param name="scale">The width and height, in pixels, of each module.</param>
+        /// <param name="foreground">The foreground color (dark modules), in RGB value (little endian).</param>
+        /// <param name="background">The background color (light modules), in RGB value (little endian).</param>
+        /// <returns>A PNG image, as a byte array.</returns>
+        /// 
+        internal static byte[] ToImage(QrCode qrCode, int scale, int border, int foreground, int background)
+        {
+            var imageSize = (qrCode.Size + border * 2) * scale;
+            var builder = new PngBuilder();
+            builder.WriteHeader(imageSize, imageSize, 1, 3);
+            builder.WritePalette(new int[] { background, foreground });
+            builder.WriteData(CreateBitmap(qrCode, border, scale));
+            builder.WriteEnd();
+            return builder.GetBytes();
+        }
+
+        /// <summary>
+        /// Creates an uncompressed 1-bit per pixel bitmap of the QR code.
+        /// </summary>
+        /// <param name="qrCode">The QR code</param>
+        /// <param name="border">The border</param>
+        /// <param name="scale">The scale</param>
+        /// <returns>Bitmap, as a byte array</returns>
+        private static byte[] CreateBitmap(QrCode qrCode, int border, int scale)
+        {
+            var size = qrCode.Size;
+            var imageSize = (size + border * 2) * scale;
+
+            var bytesPerLine = (imageSize + 7) / 8 + 1; // additional byte at the start for filter type
+            var data = new byte[bytesPerLine * imageSize];
+
+            for (var y = 0; y < size; y++)
+            {
+                var offset = (border + y) * scale * bytesPerLine;
+
+                for (var x = 0; x < size; x++)
+                {
+                    if (!qrCode.GetModule(x, y))
+                        continue;
+
+                    var pos = (border + x) * scale;
+                    var end = pos + scale;
+
+                    // set pixels for module ('scale' times)
+                    for (; pos < end; pos++)
+                    {
+                        var index = offset + pos / 8 + 1;
+                        data[index] |= (byte)(0x80U >> (pos % 8));
+                    }
+                }
+
+                // replicate line 'scale' times
+                for (var i = 1; i < scale; i++)
+                    Array.Copy(data, offset, data, offset + i * bytesPerLine, bytesPerLine);
+            }
+
+            return data;
+        }
+
+        private readonly MemoryStream stream = new MemoryStream();
+
+        /// <summary>
+        /// Returns the resulting PNG bytes.
+        /// </summary>
+        /// <returns>PNG file, as a byte array.</returns>
+        private byte[] GetBytes()
+        {
+            var bytes = stream.ToArray();
+            SetCRC(bytes);
+            return bytes;
+        }
+
+        /// <summary>
+        /// Writes the PNG header (IHDR chunk).
+        /// </summary>
+        /// <param name="width">The image width.</param>
+        /// <param name="height">The image height.</param>
+        /// <param name="bitDepth">The bits per pixel.</param>
+        /// <param name="colorType">The color type (see PNG specification).</param>
+        private void WriteHeader(int width, int height, byte bitDepth, byte colorType)
+        {
+            stream.Write(Signature, 0, Signature.Length);
+
+            WriteChunkStart(IHDR, 13);
+            WriteIntBigEndian((uint)width);
+            WriteIntBigEndian((uint)height);
+
+            stream.WriteByte(bitDepth);
+            stream.WriteByte(colorType);
+            stream.WriteByte(0);
+            stream.WriteByte(0);
+            stream.WriteByte(0);
+
+            WriteChunkEnd();
+        }
+
+        /// <summary>
+        /// Writes the palette (PLTE chunk).
+        /// </summary>
+        /// <param name="palette">The color palettes as an array of RGB values.</param>
+        private void WritePalette(int[] palette)
+        {
+            WriteChunkStart(PLTE, palette.Length * 3);
+            foreach (var color in palette)
+            {
+                stream.WriteByte((byte)((color >> 16) & 0xFF));
+                stream.WriteByte((byte)((color >> 8) & 0xFF));
+                stream.WriteByte((byte)(color & 0xFF));
+            }
+            WriteChunkEnd();
+        }
+
+        /// <summary>
+        /// Writes the pixel data (IDAT chunk).
+        /// </summary>
+        /// <param name="data">The pixel data.</param>
+        private void WriteData(byte[] data)
+        {
+            var compressedData = Deflate(data);
+            WriteChunkStart(IDAT, compressedData.Length + 6);
+
+            stream.WriteByte(0x78);
+            stream.WriteByte(0x9C);
+
+            stream.Write(compressedData, 0, compressedData.Length);
+
+            var adler = CalcAdler32(data, 0, data.Length);
+            WriteIntBigEndian(adler);
+            WriteChunkEnd();
+        }
+
+        /// <summary>
+        /// Writes the end chunk (IEND).
+        /// </summary>
+        private void WriteEnd()
+        {
+            WriteChunkStart(IEND, 0);
+            WriteChunkEnd();
+        }
+
+        private static void SetCRC(byte[] bytes)
+        {
+            var chunkOffset = Signature.Length;
+            while (chunkOffset < bytes.Length)
+            {
+                // calculate CRC
+                var dataLength = (bytes[chunkOffset] << 24) | (bytes[chunkOffset + 1] << 16) | (bytes[chunkOffset + 2] << 8) | bytes[chunkOffset + 3];
+                var crc = CalcCrc32(bytes, chunkOffset + 4, dataLength + 4);
+                var crcOffset = chunkOffset + 8 + dataLength;
+
+                // set CRC
+                bytes[crcOffset + 0] = (byte)(crc >> 24);
+                bytes[crcOffset + 1] = (byte)(crc >> 16);
+                bytes[crcOffset + 2] = (byte)(crc >> 8);
+                bytes[crcOffset + 3] = (byte)crc;
+
+                chunkOffset = crcOffset + 4;
+            }
+        }
+
+        private void WriteChunkStart(byte[] type, int length)
+        {
+            WriteIntBigEndian((uint)length);
+            stream.Write(type, 0, 4);
+        }
+
+        private void WriteChunkEnd()
+        {
+            stream.SetLength(stream.Length + 4);
+            stream.Position += 4;
+        }
+
+        private void WriteIntBigEndian(uint value)
+        {
+            stream.WriteByte((byte)(value >> 24));
+            stream.WriteByte((byte)(value >> 16));
+            stream.WriteByte((byte)(value >> 8));
+            stream.WriteByte((byte)value);
+        }
+
+        private static byte[] Deflate(byte[] data)
+        {
+            var output = new MemoryStream();
+            using (var deflater = new DeflateStream(output, CompressionLevel.Optimal))
+            {
+                deflater.Write(data, 0, data.Length);
+            }
+            return output.ToArray();
+        }
+
+        private static uint CalcAdler32(byte[] data, int index, int length)
+        {
+            const uint Base = 65521;
+            uint s1 = 1;
+            uint s2 = 0;
+
+            var end = index + length;
+            for (var n = index; n < end; n++)
+            {
+                s1 = (s1 + data[n]) % Base;
+                s2 = (s2 + s1) % Base;
+            }
+
+            return (s2 << 16) + s1;
+        }
+
+        private static uint CalcCrc32(byte[] data, int index, int length)
+        {
+            var c = 0xffffffff;
+
+            var end = index + length;
+            for (var n = index; n < end; n++)
+                c = CrcTable[(c ^ data[n]) & 0xff] ^ (c >> 8);
+
+            return c ^ 0xffffffff;
+        }
+    }
+}

QrCodeGenerator/QrCode.cs

@@ -482,6 +482,30 @@ public byte[] ToBmpBitmap(int border = 0, int scale = 1)
             return ToBmpBitmap(border, scale, 0x000000, 0xffffff);
         }
 
+        /// <summary>
+        /// Creates bitmap in the PNG format data using specified foreground and background colors for dark and light modules.
+        /// </summary>
+        /// <param name="border">The border width, as a factor of the module (QR code pixel) size.</param>
+        /// <param name="scale">The width and height, in pixels, of each module.</param>
+        /// <param name="foreground">The foreground color (dark modules), in RGB value (little endian).</param>
+        /// <param name="background">The background color (light modules), in RGB value (little endian).</param>
+        /// <returns>Bitmap data</returns>
+        public byte[] ToPngBitmap(int border, int scale, int foreground, int background)
+        {
+            return PngBuilder.ToImage(this, scale, border, foreground, background);
+        }
+
+        /// <summary>
+        /// Creates bitmap in the PNG format data using black for dark modules and white for light modules.
+        /// </summary>
+        /// <param name="border">The border width, as a factor of the module (QR code pixel) size.</param>
+        /// <param name="scale">The width and height, in pixels, of each module.</param>
+        /// <returns>Bitmap data</returns>
+        public byte[] ToPngBitmap(int border = 0, int scale = 1)
+        {
+            return PngBuilder.ToImage(this, scale, border, 0x000000, 0xffffff);
+        }
+
         /// <summary>
         /// Creates an RGB color value in little endian format.
         /// </summary>

QrCodeGeneratorTest/PngTest.cs

@@ -0,0 +1,62 @@
+/* 
+ * QR code generator library (.NET)
+ *
+ * Copyright (c) Manuel Bleichenbacher (MIT License)
+ * https://github.com/manuelbl/QrCodeGenerator
+ * 
+ */
+
+using System.IO;
+using System.Threading.Tasks;
+using VerifyTests;
+using VerifyXunit;
+using Xunit;
+using static Net.Codecrete.QrCodeGenerator.QrCode;
+
+namespace Net.Codecrete.QrCodeGenerator.Test
+{
+    public class PngTest
+    {
+        static PngTest()
+        {
+            VerifyImageMagick.Initialize();
+            VerifyImageMagick.RegisterComparers(threshold: 0.005);
+        }
+
+        private const string CodeText1 = "At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga.";
+        private const string CodeText2 = "The quick brown fox";
+
+        protected readonly VerifySettings Settings = new VerifySettings();
+
+        public PngTest()
+        {
+            Settings.UseDirectory("ReferenceFiles");
+        }
+
+        [Fact]
+        public Task PngImage()
+        {
+            var qrCode = EncodeText(CodeText1, Ecc.Medium);
+            var pngData = qrCode.ToPngBitmap(5, 3);
+
+            using (var stream = new MemoryStream(pngData))
+            {
+                return Verifier.Verify(stream, "png", Settings);
+            }
+        }
+
+
+        [Fact]
+        public Task ColorPngImage()
+        {
+            var qrCode = EncodeText(CodeText2, Ecc.Medium);
+            var pngData = qrCode.ToPngBitmap(3, 7, 0x171c80, 0xccbc9b);
+
+            using (var stream = new MemoryStream(pngData))
+            {
+                return Verifier.Verify(stream, "png", Settings);
+            }
+        }
+
+    }
+}

QrCodeGeneratorTest/QrCodeGeneratorTest.csproj

@@ -18,6 +18,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
+    <PackageReference Include="Verify.ImageMagick" Version="3.8.1" />
+    <PackageReference Include="Verify.Xunit" Version="31.9.2" />
     <PackageReference Include="xunit" Version="2.9.3" />
     <PackageReference Include="xunit.runner.visualstudio" Version="3.0.2" PrivateAssets="all" />
   </ItemGroup>

QrCodeGeneratorTest/ReferenceFiles/PngTest.ColorPngImage.verified.png

@@ -25,7 +25,6 @@
  * IN THE SOFTWARE.
  */
 
-using System;
 using System.Globalization;
 using System.IO;
 using System.Text;