Creating a Watermarked Photograph with GDI+ for .NET

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

namespace ConsoleApplication1
{
    class Program
    {

        [STAThread]
        static void Main(string[] args)
        {
            new Program().MakeWatermark("Radoslav Katreniak - watermark text",
                @"c:\img\OriginalImage.png",
                @"c:\img\LogoIcon.png",
                @"c:\img\ResultImage.png",
                0.5f);
        }

        private void MakeWatermark(string copyrightText, string originalImagePath, string watermarkImagePath, string resultImagePath, float alpha)
        {
            Image originalImage = CreateOriginalImage(originalImagePath);
            Image watermarkImage = CreateWaretmarkImage(watermarkImagePath);
            Bitmap resultImage = CreateResultImage(originalImage);
            Graphics resultGraphics = CreateResultGraphics(resultImage);
            InsertOriginalImage(originalImage, resultGraphics);
            InsertMessage(originalImage, resultGraphics, copyrightText);
            InsertWatermarkImage(watermarkImage, resultGraphics, alpha);
            SaveResultImage(resultImage, resultImagePath);
            Cleanup(originalImage, watermarkImage, resultImage, resultGraphics);
        }

        private void InsertOriginalImage(Image originalImage, Graphics resultGraphics)
        {
            //Draws the photo Image object at original size to the graphics object.
            resultGraphics.DrawImage(
                originalImage,                               // Photo Image object
                new Rectangle(0, 0, originalImage.Width, originalImage.Height), // Rectangle structure
                0,                                      // x-coordinate of the portion of the source image to draw. 
                0,                                      // y-coordinate of the portion of the source image to draw. 
                originalImage.Width,                                // Width of the portion of the source image to draw. 
                originalImage.Height,                               // Height of the portion of the source image to draw. 
                GraphicsUnit.Pixel);                    // Units of measure 
        }

        private void InsertMessage(Image originalImage, Graphics resultGraphics, string copyrightText)
        {
            Font fontType;
            SizeF fontSize;
            CalculateFontAndSizeOfText(copyrightText, originalImage, resultGraphics,  out fontType, out fontSize);

            //Since all photographs will have varying heights, determine a 
            //position 2% from the bottom of the image
            int bottonSpace = (int)(originalImage.Height * .02);

            //Now that we have a point size use the Copyrights string height 
            //to determine a y-coordinate to draw the string of the photograph
            float textPositionY = ((originalImage.Height - bottonSpace) - (fontSize.Height / 2));

            //Determine its x-coordinate by calculating the center of the width of the image
            float centerOfImgX = (originalImage.Width / 2);

            //Define the text layout by setting the text alignment to centered
            StringFormat strFormat = new StringFormat();
            strFormat.Alignment = StringAlignment.Center;

            //define a Brush which is semi trasparent black (Alpha set to 153)
            DrawWhitePartOfText(copyrightText, resultGraphics, fontType, textPositionY, centerOfImgX, strFormat);
            DrawShadowPartOfText(copyrightText, resultGraphics, fontType, textPositionY, centerOfImgX, strFormat);                       //Text alignment
        }

        private void InsertWatermarkImage(Image watermarkImage, Graphics resultGraphics, float alpha)
        {
            ImageAttributes imageAttributes = CreateImageAttributes(alpha);
            Rectangle warermarkPosition = new Rectangle(10, 10, watermarkImage.Width, watermarkImage.Height);
            resultGraphics.DrawImage(watermarkImage,
                warermarkPosition,  //Set the detination Position
                0,                  // x-coordinate of the portion of the source image to draw. 
                0,                  // y-coordinate of the portion of the source image to draw. 
                watermarkImage.Width,            // Watermark Width
                watermarkImage.Height,		    // Watermark Height
                GraphicsUnit.Pixel, // Unit of measurment
                imageAttributes);   //ImageAttributes Object
        }

        private ImageAttributes CreateImageAttributes(float alpha)
        {
            //To achieve a transulcent watermark we will apply (2) color 
            //manipulations by defineing a ImageAttributes object and 
            //seting (2) of its properties.
            ImageAttributes imageAttributes = new ImageAttributes();
            
            //The second color manipulation is used to change the opacity of the 
            //watermark.  This is done by applying a 5x5 matrix that contains the 
            //coordinates for the RGBA space.  By setting the 3rd row and 3rd column 
            //to 0.3f we achive a level of opacity
            float[][] colorMatrixElements = { 
												new float[] {1.0f,  0.0f,  0.0f,  0.0f, 0.0f},       
												new float[] {0.0f,  1.0f,  0.0f,  0.0f, 0.0f},        
												new float[] {0.0f,  0.0f,  1.0f,  0.0f, 0.0f},        
												new float[] {0.0f,  0.0f,  0.0f,  alpha, 0.0f},        
												new float[] {0.0f,  0.0f,  0.0f,  0.0f, 1.0f}};
            ColorMatrix wmColorMatrix = new ColorMatrix(colorMatrixElements);

            imageAttributes.SetColorMatrix(wmColorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
            return imageAttributes;
        }

        private void CalculateFontAndSizeOfText(string copyrightText, Image originalImage, Graphics grPhoto, out Font fontType, out SizeF fontSize)
        {
            //-------------------------------------------------------
            //to maximize the size of the Copyright message we will 
            //test multiple Font sizes to determine the largest posible 
            //font we can use for the width of the Photograph
            //define an array of point sizes you would like to consider as possiblities
            //-------------------------------------------------------
            fontType = null;
            fontSize = new SizeF();
            //Loop through the defined sizes checking the length of the Copyright string
            //If its length in pixles is less then the image width choose this Font size.
            for (int fontSizeNum = 100; fontSizeNum > 1; fontSizeNum -= 2)
            {
                //set a Font object to Arial (i)pt, Bold
                fontType = new Font("arial", fontSizeNum, FontStyle.Bold);
                //Measure the Copyright string in this Font
                fontSize = grPhoto.MeasureString(copyrightText, fontType);

                bool isTextWidthTooBig = (ushort)fontSize.Width > (ushort)(originalImage.Width * 0.98f);
                bool isTextHeightTooBig = (ushort)fontSize.Height > (ushort)(originalImage.Height * 0.04f);
                if (isTextWidthTooBig || isTextHeightTooBig)
                {
                    //take smaller font
                    continue;
                }
                break;
            }
        }

        private void DrawWhitePartOfText(string copyrightText, Graphics resultGraphics, Font fontType, float textPositionY, float centerOfImgX, StringFormat strFormat)
        {
            SolidBrush semiTransBrush = new SolidBrush(Color.FromArgb(153, 0, 0, 0));

            //Draw the Copyright string
            resultGraphics.DrawString(copyrightText,                 //string of text
                fontType,                                   //font
                semiTransBrush,                           //Brush
                new PointF(centerOfImgX + 1, textPositionY + 1),  //Position
                strFormat);
        }

        private void DrawShadowPartOfText(string copyrightText, Graphics resultGraphics, Font fontType, float textPositionY, float centerOfImgX, StringFormat strFormat)
        {

            //define a Brush which is semi trasparent white (Alpha set to 153)
            SolidBrush semiTransBrush = new SolidBrush(Color.FromArgb(153, 255, 255, 255));

            //Draw the Copyright string a second time to create a shadow effect
            //Make sure to move this text 1 pixel to the right and down 1 pixel
            resultGraphics.DrawString(copyrightText,                 //string of text
                fontType,                                   //font
                semiTransBrush,                           //Brush
                new PointF(centerOfImgX, textPositionY),  //Position
                strFormat);
        }

        private void SaveResultImage(Bitmap resultImage, string resultImageName)
        {
            resultImage.Save(resultImageName, ImageFormat.Png);
        }
        private Image CreateOriginalImage(string imageName)
        {
            Image originalImage = Image.FromFile(imageName);
            return originalImage;
        }

        private Image CreateWaretmarkImage(string watermarkImageName)
        {
            Image watermarkImage = new Bitmap(watermarkImageName);
            return watermarkImage;
        }

        private Bitmap CreateResultImage(Image originalImage)
        {
            Bitmap resultImage = new Bitmap(originalImage.Width, originalImage.Height, PixelFormat.Format24bppRgb);

            resultImage.SetResolution(originalImage.HorizontalResolution, originalImage.VerticalResolution);
            return resultImage;
        }


        private static Graphics CreateResultGraphics(Bitmap resultImage)
        {
            Graphics resultGraphics = Graphics.FromImage(resultImage);
            resultGraphics.SmoothingMode = SmoothingMode.AntiAlias;
            return resultGraphics;
        }

        private void Cleanup(Image originalImage, Image watermarkImage, Bitmap resultImage, Graphics resultGraphics)
        {
            resultImage.Dispose();
            originalImage.Dispose();
            resultGraphics.Dispose();
            watermarkImage.Dispose();
        }
    }
}