Как изменить размер bitmap c

Here you can find also add watermark codes in this class :

public class ImageProcessor
    {
        public Bitmap Resize(Bitmap image, int newWidth, int newHeight, string message)
        {
            try
            {
                Bitmap newImage = new Bitmap(newWidth, Calculations(image.Width, image.Height, newWidth));

                using (Graphics gr = Graphics.FromImage(newImage))
                {
                    gr.SmoothingMode = SmoothingMode.AntiAlias;
                    gr.InterpolationMode = InterpolationMode.HighQualityBicubic;
                    gr.PixelOffsetMode = PixelOffsetMode.HighQuality;
                    gr.DrawImage(image, new Rectangle(0, 0, newImage.Width, newImage.Height));

                    var myBrush = new SolidBrush(Color.FromArgb(70, 205, 205, 205));

                    double diagonal = Math.Sqrt(newImage.Width * newImage.Width + newImage.Height * newImage.Height);

                    Rectangle containerBox = new Rectangle();

                    containerBox.X = (int)(diagonal / 10);
                    float messageLength = (float)(diagonal / message.Length * 1);
                    containerBox.Y = -(int)(messageLength / 1.6);

                    Font stringFont = new Font("verdana", messageLength);

                    StringFormat sf = new StringFormat();

                    float slope = (float)(Math.Atan2(newImage.Height, newImage.Width) * 180 / Math.PI);

                    gr.RotateTransform(slope);
                    gr.DrawString(message, stringFont, myBrush, containerBox, sf);
                    return newImage;
                }
            }
            catch (Exception exc)
            {
                throw exc;
            }
        }

        public int Calculations(decimal w1, decimal h1, int newWidth)
        {
            decimal height = 0;
            decimal ratio = 0;


            if (newWidth < w1)
            {
                ratio = w1 / newWidth;
                height = h1 / ratio;

                return height.To<int>();
            }

            if (w1 < newWidth)
            {
                ratio = newWidth / w1;
                height = h1 * ratio;
                return height.To<int>();
            }

            return height.To<int>();
        }

    }

Here you can find also add watermark codes in this class :

public class ImageProcessor
    {
        public Bitmap Resize(Bitmap image, int newWidth, int newHeight, string message)
        {
            try
            {
                Bitmap newImage = new Bitmap(newWidth, Calculations(image.Width, image.Height, newWidth));

                using (Graphics gr = Graphics.FromImage(newImage))
                {
                    gr.SmoothingMode = SmoothingMode.AntiAlias;
                    gr.InterpolationMode = InterpolationMode.HighQualityBicubic;
                    gr.PixelOffsetMode = PixelOffsetMode.HighQuality;
                    gr.DrawImage(image, new Rectangle(0, 0, newImage.Width, newImage.Height));

                    var myBrush = new SolidBrush(Color.FromArgb(70, 205, 205, 205));

                    double diagonal = Math.Sqrt(newImage.Width * newImage.Width + newImage.Height * newImage.Height);

                    Rectangle containerBox = new Rectangle();

                    containerBox.X = (int)(diagonal / 10);
                    float messageLength = (float)(diagonal / message.Length * 1);
                    containerBox.Y = -(int)(messageLength / 1.6);

                    Font stringFont = new Font("verdana", messageLength);

                    StringFormat sf = new StringFormat();

                    float slope = (float)(Math.Atan2(newImage.Height, newImage.Width) * 180 / Math.PI);

                    gr.RotateTransform(slope);
                    gr.DrawString(message, stringFont, myBrush, containerBox, sf);
                    return newImage;
                }
            }
            catch (Exception exc)
            {
                throw exc;
            }
        }

        public int Calculations(decimal w1, decimal h1, int newWidth)
        {
            decimal height = 0;
            decimal ratio = 0;


            if (newWidth < w1)
            {
                ratio = w1 / newWidth;
                height = h1 / ratio;

                return height.To<int>();
            }

            if (w1 < newWidth)
            {
                ratio = newWidth / w1;
                height = h1 * ratio;
                return height.To<int>();
            }

            return height.To<int>();
        }

    }

1. Resize an Image With the Bitmap Class in C#
2. Resize an Image With the Graphics.DrawImage() Function in C#

In this tutorial, we will discuss methods to resize an image in C#.

Resize an Image With the Bitmap Class in C#

The Bitmap class provides many methods to work with images in C#. The Bitmap class gets the pixel data of images. We can resize an image by initializing the Size parameter inside the constructor of the Bitmap class.

The following code example shows us how we can resize an image with the constructor of the Bitmap class in C#.

using System;
using System.Drawing;
namespace resize_image
{
    class Program
    {
        public static Image resizeImage(Image imgToResize, Size size)
        {
            return (Image)(new Bitmap(imgToResize, size));
        }
        static void Main(string[] args)
        {
            string path = "C:\Images\img1.jpg";
            Image img = Image.FromFile(path);
            Bitmap imgbitmap = new Bitmap(img);
            Image resizedImage = resizeImage(imgbitmap, new Size(200, 200));
        }
    }
}

We resized the image img inside the path C:Imagesimg1.jpg with the constructor of the Bitmap class in C#. We created the bitmap imgbitmap to get the pixel data of the image img. We passed the imgbitmap and new Size(100, 100) to the resizeImage() function. The resizeImage() creates a new bitmap with the specified image and size, casts it to image data type, and then returns the value. The value returned by the resizeImage() function is stored inside the resizedImage image.

Resize an Image With the Graphics.DrawImage() Function in C#

The Graphics.DrawImage() function draws an image inside a specified location with specified dimensions in C#. With this method, we can eliminate many drawbacks of resizing an image. The following code example shows us how we can resize an image with the Graphics.DrawImage() function in C#.

using System;
using System.Drawing;
namespace resize_image
{
    class Program
    {
        public static Image resizeImage(Image image, int width, int height)
        {
            var destinationRect = new Rectangle(0, 0, width, height);
            var destinationImage = new Bitmap(width, height);

            destinationImage.SetResolution(image.HorizontalResolution, image.VerticalResolution);

            using (var graphics = Graphics.FromImage(destinationImage))
            {
                graphics.CompositingMode = CompositingMode.SourceCopy;
                graphics.CompositingQuality = CompositingQuality.HighQuality;

                using (var wrapMode = new ImageAttributes())
                {
                    wrapMode.SetWrapMode(WrapMode.TileFlipXY);
                    graphics.DrawImage(image, destinationRect, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, wrapMode);
                }
            }

            return (Image) destinationImage;
        }
        static void Main(string[] args)
        {
            string path = "C:\Images\img1.jpg";
            Image img = Image.FromFile(path);
            Bitmap imgbitmap = new Bitmap(img);
            Image resizedImage = resizeImage(imgbitmap, new Size(200, 200));
        }
    }
}

In the above code, the destinationImage.SetResolution() function maintains the dpi of the image regardless of its actual size. The graphics.CompositingMode = CompositingMode.SourceCopy property specifies that when a color is rendered it overwrites the background color. The graphics.CompositingQuality = CompositingQuality.HighQuality property specifies that we only want high quality image to be rendered. The wrapMode.SetWrapMode(WrapMode.TileFlipXY) function prevents ghosting around the image borders. In the end, the graphics.DrawImage() draws the actual image with the specified dimensions.

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Text;

using System.Windows.Forms;

using System.Drawing;

using System.Drawing.Drawing2D;

using System.Drawing.Imaging;

namespace ImageZoom

{

    public partial class Form1 : Form

    {

        private Rectangle selectedArea;

        private Image loadedImage;

        private Image thumbnail;

        private Color selectionColor;

        public Form1()

        {

            InitializeComponent();

            //область масштабирования в эскизе

            selectedArea = new Rectangle(0, 0, 40, 20);

        }

        private void btnOpen_Click(object sender, EventArgs e)

        {

            if (openFileDialog1.ShowDialog() == DialogResult.OK)

            {

                if (loadedImage != null)

                {

                    loadedImage.Dispose();

                    thumbnail.Dispose();

                }

                try

                {

                    loadedImage = Image.FromFile(openFileDialog1.FileName);

                    //Получение контрастного цвета для маркера выделения изображения

                    using (Bitmap bmp = new Bitmap(loadedImage))

                    {

                        selectionColor = GetDominantColor(bmp, false);

                        selectionColor = CalculateOppositeColor(selectionColor);

                    }

                    tZoom.Value = 1;

                    resizePictureArea();

                    updateZoom();

                }

                catch (Exception)

                {

                    MessageBox.Show(«Invalid image»);

                }                

            }

            picSmall.Invalidate();

        }

        /// <summary>

        /// Растягивает выделенную область масштабирования изображения

        /// </summary>

        private Image ZoomImage(Image input, Rectangle zoomArea, Rectangle sourceArea)

        {

            Bitmap newBmp = new Bitmap(sourceArea.Width, sourceArea.Height);

            using (Graphics g = Graphics.FromImage(newBmp))

            {

                //высокая интерполяция

                g.InterpolationMode = InterpolationMode.HighQualityBicubic;

                g.DrawImage(input, sourceArea, zoomArea, GraphicsUnit.Pixel);

            }

            return newBmp;

        }

        /// <summary>

        /// Рисует прямоугольник выделения на изображении

        /// </summary>

        private Image MarkImage(Image input, Rectangle selectedArea, Color selectColor)

        {

            Bitmap newImg = new Bitmap(input.Width, input.Height);

            using (Graphics g = Graphics.FromImage(newImg))

            {

                //Запретить использование внутренних эскизов изображений

                input.RotateFlip(RotateFlipType.Rotate180FlipNone);

                input.RotateFlip(RotateFlipType.Rotate180FlipNone);

                g.DrawImage(input, 0, 0);

                //Изменение размера изображения

                using (Pen p = new Pen(selectColor))

                    g.DrawRectangle(p, selectedArea);

            }

            return (Image)newImg;

        }

        /// <summary>

        /// Изменение размера изображения

        /// </summary>

        private Image ResizeImage(Image input, Size newSize, InterpolationMode interpolation)

        {

            Bitmap newImg = new Bitmap(newSize.Width, newSize.Height);

            using (Graphics g = Graphics.FromImage(newImg))

            {

                //Запретить использование внутренних эскизов изображений

                input.RotateFlip(RotateFlipType.Rotate180FlipNone);

                input.RotateFlip(RotateFlipType.Rotate180FlipNone);

                //Интерполяция

                g.InterpolationMode = interpolation;

                //Нарисуйте изображение с новыми измерениями

                g.DrawImage(input, 0, 0, newSize.Width, newSize.Height);

            }

            return (Image)newImg;

        }

        /// <summary>

        /// Возвращает доминирующий цвет изображения.e

        /// </summary>

        private Color GetDominantColor(Bitmap bmp, bool includeAlpha)

        {

            // GDI+ по-прежнему лжет нам — формат возврата BGRA, а не ARGB.

            BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),

                                           ImageLockMode.ReadWrite,

                                           PixelFormat.Format32bppArgb);

            int stride = bmData.Stride;

            IntPtr Scan0 = bmData.Scan0;

            int r = 0;

            int g = 0;

            int b = 0;

            int a = 0;

            int total = 0;

            unsafe

            {

                byte* p = (byte*)(void*)Scan0;

                int nOffset = stride — bmp.Width * 4;

                int nWidth = bmp.Width;

                for (int y = 0; y < bmp.Height; y++)

                {

                    for (int x = 0; x < nWidth; x++)

                    {

                        r += p[0];

                        g += p[1];

                        b += p[2];

                        a += p[3];

                        total++;

                        p += 4;

                    }

                    p += nOffset;

                }

            }

            bmp.UnlockBits(bmData);

            r /= total;

            g /= total;

            b /= total;

            a /= total;

            if (includeAlpha)

                return Color.FromArgb(a, r, g, b);

            else

                return Color.FromArgb(r, g, b);

        }

        /// <summary>

        /// Вычисляет цвет, противоположный заданному цвету.

        /// </summary>

        /// <param name=»clr»></param>

        /// <returns></returns>

        private Color CalculateOppositeColor(Color clr)

        {

            return Color.FromArgb(255 — clr.R, 255 — clr.G, 255 — clr.B);

        }

        /// <summary>

        /// Сужает набор заданных размеров, сохраняя при этом соотношение сторон.

        /// </summary>

        private Size ShrinkToDimensions(int originalWidth, int originalHeight, int maxWidth, int maxHeight)

        {

            int newWidth = 0;

            int newHeight = 0;

            if (originalWidth >= originalHeight)

            {

                //Сопоставьте ширину площади с максимальной шириной

                if (originalWidth <= maxWidth)

                {

                    newWidth = originalWidth;

                    newHeight = originalHeight;

                }

                else

                {

                    newWidth = maxWidth;

                    newHeight = originalHeight * maxWidth / originalWidth;

                }

            }

            else

            {

                //Сопоставьте высоту площади с максимальной высотой

                if (originalHeight <= maxHeight)

                {

                    newWidth = originalWidth;

                    newHeight = originalHeight;

                }

                else

                {

                    newWidth = originalWidth * maxHeight / originalHeight;

                    newHeight = maxHeight;

                }

            }

            return new Size(newWidth, newHeight);

        }

        private void resizePictureArea()

        {

            //Создание эскиза изображения (с сохранением пропорций)

            Size newSize = ShrinkToDimensions(loadedImage.Width, loadedImage.Height, 160, 130);

            //используйте низкую интерполяцию

            thumbnail = ResizeImage(loadedImage, new Size(newSize.Width, newSize.Height), InterpolationMode.Low);

            picSmall.Invalidate();

        }

        private void updateZoom()

        {

            if (loadedImage != null)

            {

                //Сопоставление области, выбранной в миниатюре, с фактическим размером изображения

                Rectangle zoomArea = new Rectangle();

                zoomArea.X = selectedArea.X * loadedImage.Width / thumbnail.Width;

                zoomArea.Y = selectedArea.Y * loadedImage.Height / thumbnail.Height;

                zoomArea.Width = selectedArea.Width * loadedImage.Width / thumbnail.Width;

                zoomArea.Height = selectedArea.Height * loadedImage.Height / thumbnail.Height;

                //Настройка выбранной области в соответствии с текущим значением масштаба

                zoomArea.Width /= tZoom.Value;

                zoomArea.Height /= tZoom.Value;

                picZoom.Image = ZoomImage(loadedImage, zoomArea, picZoom.ClientRectangle);

                picZoom.Refresh();

            }

        }

        private void picSmall_Paint(object sender, PaintEventArgs e)

        {

            if (loadedImage != null)

            {

                //Настройка выделенной области в соответствии со значением масштаба

                Rectangle adjustedArea = new Rectangle();

                adjustedArea.X = selectedArea.X;

                adjustedArea.Y = selectedArea.Y;

                adjustedArea.Width = selectedArea.Width / tZoom.Value;

                adjustedArea.Height = selectedArea.Height / tZoom.Value;

                //Рисование выделенной области на эскизе

                picSmall.Image = MarkImage(thumbnail, adjustedArea, selectionColor);

            }

        }

        private void picSmall_Click(object sender, EventArgs e)

        {

            //Обновление выбранной области, когда пользователь нажимает на миниатюру

            Point mouseLoc = picSmall.PointToClient(Cursor.Position);

            selectedArea.X = mouseLoc.X — ((selectedArea.Width / tZoom.Value) / 2);

            selectedArea.Y = mouseLoc.Y — ((selectedArea.Height / tZoom.Value) / 2);

            //Привязка поля к границам области рисунка

            if (selectedArea.Left < 0)

                selectedArea.X = 0;

            else if (selectedArea.Right > picSmall.Width)

                selectedArea.X = picSmall.Width — selectedArea.Width — 1;

            if (selectedArea.Top < 0)

                selectedArea.Y = 0;

            else if (selectedArea.Bottom > picSmall.Height)

                selectedArea.Y = picSmall.Height — selectedArea.Height — 1;

            picSmall.Invalidate();

            updateZoom();

        }

        private void tValue_Scroll(object sender, EventArgs e)

        {

            updateZoom();

        }

    }

}

В приложении, которое я сделал, необходимо было создать функцию с несколькими параметрами. Он довольно большой, но он изменяет размер изображения, может сохранять соотношение сторон и может вырезать края, чтобы вернуть только центр изображения:

/// <summary>
    /// Resize image with a directory as source
    /// </summary>
    /// <param name="OriginalFileLocation">Image location</param>
    /// <param name="heigth">new height</param>
    /// <param name="width">new width</param>
    /// <param name="keepAspectRatio">keep the aspect ratio</param>
    /// <param name="getCenter">return the center bit of the image</param>
    /// <returns>image with new dimentions</returns>
    public Image resizeImageFromFile(String OriginalFileLocation, int heigth, int width, Boolean keepAspectRatio, Boolean getCenter)
    {
        int newheigth = heigth;
        System.Drawing.Image FullsizeImage = System.Drawing.Image.FromFile(OriginalFileLocation);

        // Prevent using images internal thumbnail
        FullsizeImage.RotateFlip(System.Drawing.RotateFlipType.Rotate180FlipNone);
        FullsizeImage.RotateFlip(System.Drawing.RotateFlipType.Rotate180FlipNone);

        if (keepAspectRatio || getCenter)
        {
            int bmpY = 0;
            double resize = (double)FullsizeImage.Width / (double)width;//get the resize vector
            if (getCenter)
            {
                bmpY = (int)((FullsizeImage.Height - (heigth * resize)) / 2);// gives the Y value of the part that will be cut off, to show only the part in the center
                Rectangle section = new Rectangle(new Point(0, bmpY), new Size(FullsizeImage.Width, (int)(heigth * resize)));// create the section to cut of the original image
                //System.Console.WriteLine("the section that will be cut off: " + section.Size.ToString() + " the Y value is minimized by: " + bmpY);
                Bitmap orImg = new Bitmap((Bitmap)FullsizeImage);//for the correct effect convert image to bitmap.
                FullsizeImage.Dispose();//clear the original image
                using (Bitmap tempImg = new Bitmap(section.Width, section.Height))
                {
                    Graphics cutImg = Graphics.FromImage(tempImg);//              set the file to save the new image to.
                    cutImg.DrawImage(orImg, 0, 0, section, GraphicsUnit.Pixel);// cut the image and save it to tempImg
                    FullsizeImage = tempImg;//save the tempImg as FullsizeImage for resizing later
                    orImg.Dispose();
                    cutImg.Dispose();
                    return FullsizeImage.GetThumbnailImage(width, heigth, null, IntPtr.Zero);
                }
            }
            else newheigth = (int)(FullsizeImage.Height / resize);//  set the new heigth of the current image
        }//return the image resized to the given heigth and width
        return FullsizeImage.GetThumbnailImage(width, newheigth, null, IntPtr.Zero);
    }

Чтобы облегчить доступ к функции, можно добавить некоторые перегруженные функции:

/// <summary>
    /// Resize image with a directory as source
    /// </summary>
    /// <param name="OriginalFileLocation">Image location</param>
    /// <param name="heigth">new height</param>
    /// <param name="width">new width</param>
    /// <returns>image with new dimentions</returns>
    public Image resizeImageFromFile(String OriginalFileLocation, int heigth, int width)
    {
        return resizeImageFromFile(OriginalFileLocation, heigth, width, false, false);
    }

    /// <summary>
    /// Resize image with a directory as source
    /// </summary>
    /// <param name="OriginalFileLocation">Image location</param>
    /// <param name="heigth">new height</param>
    /// <param name="width">new width</param>
    /// <param name="keepAspectRatio">keep the aspect ratio</param>
    /// <returns>image with new dimentions</returns>
    public Image resizeImageFromFile(String OriginalFileLocation, int heigth, int width, Boolean keepAspectRatio)
    {
        return resizeImageFromFile(OriginalFileLocation, heigth, width, keepAspectRatio, false);
    }

Теперь это два последних логических параметра, которые необходимо установить.
Вызовите функцию следующим образом:

System.Drawing.Image ResizedImage = resizeImageFromFile(imageLocation, 800, 400, true, true);