BeWoPlaner/BeWoPlanerMobil/Util/SignatureUtils.cs

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

namespace BeWoPlanerMobil.Util
{
    public class SignatureUtils
    {
        public static bool ValidateSignature(Bitmap signatureBitmap)
        {
            if(signatureBitmap is null)
            {
                return false;
            }

            var nonTransparentPixelCount = 0;

            for(var x = 0; x < signatureBitmap.Width; x++)
            {
                for(var y = 0; y < signatureBitmap.Height; y++)
                {
                    var pixel = signatureBitmap.GetPixel(x, y);

                    if((pixel.A != 255 || pixel.R != 255 || pixel.G != 255 || pixel.B != 255) && (pixel.A != 0 || pixel.R != 0 || pixel.G != 0 || pixel.B != 0))
                    {
                        nonTransparentPixelCount++;
                    }

                    if(nonTransparentPixelCount == 20)
                    {
                        return true;
                    }
                }
            }

            return false;
        }

        public static bool HasTransparentBackground(string base64Image)
        {
            if(string.IsNullOrWhiteSpace(base64Image))
            {
                return true;
            }

            if(base64Image.Contains(","))
            {
                base64Image = base64Image.Split(',')[1];
            }

            var whitePixelCount = 0;

            using(var bitmap = Base64StringToBitmap(base64Image))
            {
                if(bitmap.Width == 0 || bitmap.Height == 0)
                {
                    return true;
                }

                for(var x = 0; x < bitmap.Width; x++)
                {
                    for(var y = 0; y < bitmap.Height; y++)
                    {
                        var pixel = bitmap.GetPixel(x, y);

                        if(pixel.R == 255 && pixel.G == 255 && pixel.B == 255)
                        {
                            whitePixelCount++;
                        }

                        if(whitePixelCount == 20)
                        {
                            return false;
                        }
                    }
                }
            }
            
            return true;
        }

        public static Bitmap Base64StringToBitmap(string base64String)
        {
            Bitmap bitmap;

            var imageString = base64String.Contains(",") ? base64String.Split(',')[1] : base64String;

            var byteBuffer = Convert.FromBase64String(imageString);

            using(var memoryStream = new MemoryStream(byteBuffer))
            {
                memoryStream.Position = 0;
                bitmap = (Bitmap) Image.FromStream(memoryStream);
                byteBuffer = null;
            }

            return bitmap;
        }

        public static string ConvertImageToBase64String(Image image)
        {
            string base64Image;

            using(var memoryStream = new MemoryStream())
            {
                image.Save(memoryStream, ImageFormat.Bmp);

                var imageBytes = memoryStream.ToArray();
                base64Image = Convert.ToBase64String(imageBytes);
            }

            return base64Image;
        }

        public static Bitmap AddBackgroundToBitmap(Bitmap bitmap, Color newBackgroundColor)
        {
            var nonTransparentBitmap = new Bitmap(bitmap.Width, bitmap.Height);
            var rectangle = new Rectangle(Point.Empty, bitmap.Size);

            using(var graphics = Graphics.FromImage(nonTransparentBitmap))
            {
                graphics.Clear(newBackgroundColor);
                graphics.DrawImageUnscaledAndClipped(bitmap, rectangle);
            }

            return nonTransparentBitmap;
        }
    }
}