Rename and make pixels crop to module pixels size

Author: NigelThorne

QRCoder/LogoQRCode.cs renamed to QRCoder/ArtQRCode.cs

@@ -7,32 +7,33 @@
 // pull request raised to extend library used. 
 namespace QRCoder
 {
-    public class LogoQRCode : AbstractQRCode, IDisposable
+    public class ArtQRCode : AbstractQRCode, IDisposable
     {
         /// <summary>
         /// Constructor without params to be used in COM Objects connections
         /// </summary>
-        public LogoQRCode() { }
+        public ArtQRCode() { }
 
-        public LogoQRCode(QRCodeData data) : base(data) { }
+        public ArtQRCode(QRCodeData data) : base(data) { }
 
-        public Bitmap GetGraphic(Bitmap backgroundImage = null)
+        public Bitmap GetGraphic(int pixelsPerModule)
         {
-            return this.GetGraphic(10, 7, Color.Black, Color.White, backgroundImage: backgroundImage);
+            return this.GetGraphic(pixelsPerModule, (pixelsPerModule * 8) / 10, Color.Black, Color.White);
         }
 
-        public Bitmap GetGraphic(int pixelsPerModule, Bitmap backgroundImage = null)
+        public Bitmap GetGraphic(Bitmap backgroundImage = null)
         {
-            return this.GetGraphic(pixelsPerModule, (pixelsPerModule * 8) / 10, Color.Black, Color.White, backgroundImage: backgroundImage);
+            return this.GetGraphic(10, 7, Color.Black, Color.White, backgroundImage: backgroundImage);
         }
 
-        public Bitmap GetGraphic(int pixelsPerModule,
+        public Bitmap GetGraphic(
+            int pixelsPerModule,
             int pixelSize,
             Color darkColor,
             Color lightColor,
-            Bitmap backgroundImage = null,
             bool drawQuietZones = false,
-            Bitmap reticleImage = null)
+            Bitmap reticleImage = null,
+            Bitmap backgroundImage = null)
         {
             int numModules = this.QrCodeData.ModuleMatrix.Count - (drawQuietZones ? 0 : 8);
             var offset = (drawQuietZones ? 0 : 4);
@@ -42,6 +43,7 @@ public Bitmap GetGraphic(int pixelsPerModule,
             Bitmap bitmap = backgroundImage ?? new Bitmap(size, size);
             bitmap = Resize(bitmap, size);
 
+
             using (Graphics graphics = Graphics.FromImage(bitmap))
             {
                 using (SolidBrush lightBrush = new SolidBrush(lightColor))
@@ -57,21 +59,23 @@ public Bitmap GetGraphic(int pixelsPerModule,
                             }
                         }
 
+                        var darkModulePixel = MakeDotPixel(pixelsPerModule, pixelSize, darkBrush);
+                        var lightModulePixel = MakeDotPixel(pixelsPerModule, pixelSize, lightBrush);
+
                         for (int x = 0; x < numModules; x += 1)
                         {
                             for (int y = 0; y < numModules; y += 1)
                             {
-                                var solidBrush = (Brush)(this.QrCodeData.ModuleMatrix[offset + y][offset + x] ? darkBrush : lightBrush);
-
-                                if (IsPartOfReticle(x, y, numModules, offset))
-                                {
-                                    if (reticleImage == null)
-                                    {
-                                        graphics.FillRectangle(solidBrush, new Rectangle(x * pixelsPerModule, y * pixelsPerModule, pixelsPerModule, pixelsPerModule));
-                                    }
-                                }
-                                else
-                                    graphics.FillEllipse(solidBrush, new Rectangle(x * pixelsPerModule + moduleMargin, y * pixelsPerModule + moduleMargin, pixelSize, pixelSize));
+                                var rectangleF = new Rectangle(x * pixelsPerModule, y * pixelsPerModule, pixelsPerModule, pixelsPerModule);
+
+                                var pixelIsDark = this.QrCodeData.ModuleMatrix[offset + y][offset + x];
+                                var solidBrush = pixelIsDark ? darkBrush : lightBrush;
+                                var pixelImage = pixelIsDark ? darkModulePixel : lightModulePixel;
+
+                                if (!IsPartOfReticle(x, y, numModules, offset))
+                                    graphics.DrawImage(pixelImage, rectangleF);
+                                else if (reticleImage == null)
+                                    graphics.FillRectangle(solidBrush, rectangleF);
                             }
                         }
 
@@ -90,6 +94,39 @@ public Bitmap GetGraphic(int pixelsPerModule,
             return bitmap;
         }
 
+        /// <summary>
+        /// If the pixelSize is bigger than the pixelsPerModule or may end up filling the Module making a traditional QR code.
+        /// </summary>
+        /// <param name="pixelsPerModule"></param>
+        /// <param name="pixelSize"></param>
+        /// <param name="brush"></param>
+        /// <returns></returns>
+        private Bitmap MakeDotPixel(int pixelsPerModule, int pixelSize, SolidBrush brush)
+        {
+            // draw a dot
+            var bitmap = new Bitmap(pixelSize, pixelSize);
+            using (var graphics = Graphics.FromImage(bitmap))
+            {
+                graphics.FillEllipse(brush, new Rectangle(0, 0, pixelSize, pixelSize));
+                graphics.Save();
+            }
+
+            var pixelWidth = Math.Min(pixelsPerModule, pixelSize);
+            var margin = Math.Max((pixelsPerModule - pixelWidth) / 2, 0);
+
+            // center the dot in the module and crop to stay the right size.
+            var cropped = new Bitmap(pixelsPerModule, pixelsPerModule);
+            using (var graphics = Graphics.FromImage(cropped))
+            {
+                graphics.DrawImage(bitmap, new Rectangle(margin, margin, pixelWidth, pixelWidth),
+                    new RectangleF(((float)pixelSize - pixelWidth) / 2, ((float)pixelSize - pixelWidth) / 2, pixelWidth, pixelWidth),
+                    GraphicsUnit.Pixel);
+                graphics.Save();
+            }
+
+            return cropped;
+        }
+
         private bool IsPartOfReticle(int x, int y, int numModules, int offset)
         {
             var cornerSize = 11 - offset;
@@ -99,25 +136,36 @@ private bool IsPartOfReticle(int x, int y, int numModules, int offset)
                 (x < cornerSize && y > (numModules - cornerSize - 1));
         }
 
-        private Bitmap Resize(Bitmap image, int size)
+        /// <summary>
+        /// Resize to a square bitmap, but maintain the aspect ratio by padding transparently.
+        /// </summary>
+        /// 
+        /// <param name="image"></param>
+        /// <param name="newSize"></param>
+        /// <returns></returns>
+        private Bitmap Resize(Bitmap image, int newSize)
         {
-            float scale = Math.Min((float)size / image.Width, (float)size / image.Height);
-            var scaleWidth = (int)(image.Width * scale);
-            var scaleHeight = (int)(image.Height * scale);
-            var scaledImage = new Bitmap(image, new Size(scaleWidth, scaleHeight));
+            float scale = Math.Min((float)newSize / image.Width, (float)newSize / image.Height);
+            var scaledWidth = (int)(image.Width * scale);
+            var scaledHeight = (int)(image.Height * scale);
+            var offsetX = (newSize - scaledWidth) / 2;
+            var offsetY = (newSize - scaledHeight) / 2;
+
+            var scaledImage = new Bitmap(image, new Size(scaledWidth, scaledHeight));
 
-            var bm = new Bitmap(size, size);
+            var bm = new Bitmap(newSize, newSize);
 
             using (Graphics graphics = Graphics.FromImage(bm))
             {
                 using (var brush = new SolidBrush(Color.Transparent))
                 {
-                    graphics.FillRectangle(brush, new Rectangle(0, 0, size, size));
+                    graphics.FillRectangle(brush, new Rectangle(0, 0, newSize, newSize));
 
                     graphics.InterpolationMode = InterpolationMode.High;
                     graphics.CompositingQuality = CompositingQuality.HighQuality;
                     graphics.SmoothingMode = SmoothingMode.AntiAlias;
-                    graphics.DrawImage(scaledImage, new Rectangle((size / 2) - (scaledImage.Width / 2), (size / 2) - (scaledImage.Height / 2), scaledImage.Width, scaledImage.Height));
+
+                    graphics.DrawImage(scaledImage, new Rectangle(offsetX, offsetY, scaledWidth, scaledHeight));
                 }
             }