Image Thumbnails ASP.NET

Question

Hi. I'm trying to genererate thumbnails from image files stored in a folder under the website root, I am currently using the built in capebilites in .NET to dynamically generate the thumbnails but the quality gets quite bad and since its an webshop thats a real problem my question is if there is any good (open source?) frameworks that can help me hanlde the image thumbnail creation and rezise and possible help with image file size compression during upload?

I've looked but havent found any yet?

Thanks in advance.

Answer 1

I've written some code you could use. Please don't sell it ;)

This is the code:

/*
 *  Software Developed by Filip Ekberg ( [email protected] )
 * 
 *  For Questions regarding this software, please send me an E-mail
 * 
 */

#region Usings
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
#endregion

namespace ImageResizer
{
    class ImageProcessor
    {
        #region Members
        private int m_imgWidht,
                    m_imgHeight,
                    m_oImgWidht,
                    m_oImgHeight;

        private float m_vertRes,
                      m_horiRes;

        private double m_size = 0.25;

        private Bitmap m_Bitmap;
        private Graphics m_Graphics;
        private Image m_currentImage;

        private PixelFormat m_pxlFormat = PixelFormat.Format32bppRgb;
        private InterpolationMode m_interpolationMode = InterpolationMode.HighQualityBilinear;
        private CompositingQuality m_compositingQuality = CompositingQuality.HighQuality;
        private SmoothingMode m_smoothingMode = SmoothingMode.None;
        #endregion

        #region Access Methods

        public int ImageWidth 
        {
            get { return m_imgWidht; }
        }
        public int ImageHeight 
       {
            get { return m_imgHeight; }
        }
        public float VerticalResolution
        {
            get { return m_vertRes; }
            set { m_vertRes = value; }
        }
        public float HorizonalResolution
        {
            get { return m_horiRes; }
            set { m_horiRes = value; }
        }

        /// <summary>
        /// Use ImageSize struct for setting this.
        /// </summary>
        public double Size
        {
            get { return m_size; }
            set { m_size = value; }
        }
        public Image ProcessImage
        {
            get { return m_currentImage; }
            set { m_currentImage = value; }
        }
        public PixelFormat ImagePixelFormat 
        {
            get { return m_pxlFormat; }
            set { m_pxlFormat = value; }
        }
        public InterpolationMode ImageInterpolationMode
        {
            get { return m_interpolationMode; }
            set { m_interpolationMode = value; }
        }
        public CompositingQuality ImageCompositingQuality
        {
            get { return m_compositingQuality; }
            set { m_compositingQuality = value; }
        }
        public SmoothingMode ImageSmoothingMode
        {
            get { return m_smoothingMode; }
            set { m_smoothingMode = value; }
        }

        #endregion

        #region Process Image
        public Bitmap BeginProcess()
        {
            if ( m_currentImage == null )
                return null;

            m_oImgWidht = m_currentImage.Width;
            m_oImgHeight = m_currentImage.Height;

            m_vertRes = m_currentImage.VerticalResolution;
            m_horiRes = m_currentImage.HorizontalResolution;

            m_imgWidht = (int)(m_oImgWidht * (double)m_size);
            m_imgHeight = (int)(m_oImgHeight * (double)m_size);


            m_Bitmap = new Bitmap(m_imgWidht, m_imgHeight, m_pxlFormat);

            m_Bitmap.SetResolution(m_vertRes, m_horiRes);

            m_Graphics = Graphics.FromImage(m_Bitmap);

            m_Graphics.InterpolationMode = m_interpolationMode;

            m_Graphics.CompositingQuality = m_compositingQuality;

            m_Graphics.SmoothingMode = m_smoothingMode;

            // m_Graphics.DrawImage(m_currentImage, new Rectangle(0, 0, m_imgWidht, m_imgHeight), new Rectangle(0, 0, m_oImgWidht, m_oImgHeight), GraphicsUnit.Pixel);

            Rectangle rectDestination = new Rectangle(0, 0, m_imgWidht, m_imgHeight);
           // m_Graphics.DrawImage(m_currentImage,
           //     new Rectangle(-1, -1, m_oImgWidht + 2, m_oImgHeight + 2),
            //    new Rectangle(m_oImgWidht, m_oImgHeight, m_imgWidht, m_oImgHeight),
            //    GraphicsUnit.Pixel);
            ImageAttributes ia = new ImageAttributes();
            ia.SetWrapMode(WrapMode.TileFlipXY);
            m_Graphics.DrawImage(m_currentImage, rectDestination, 0, 0, m_oImgWidht, m_oImgHeight, GraphicsUnit.Pixel, ia); 

            // m_Graphics.Dispose();

            return m_Bitmap;
        }
        #endregion
    }
}

This is how you might use it:

private ImageProcessor m_processor = new ImageProcessor();


m_currentImage = new Bitmap(currentFile.FullName);

                // Display a Thumbnail of it
                pictureBox1.Image = m_currentImage.GetThumbnailImage(pictureBox1.Width, pictureBox1.Height, null, IntPtr.Zero);

                // Update the Label with Filename and what file is currently processed
                delegate_lblControl(currentFile.Name + "\n" + m_currentProcessedImage + " / " + m_fileList.Length);

                // Increase the value on the ProcessBar
                delegate_imageProcessValue(1);

                // Process the Image
                m_processor.ProcessImage = m_currentImage;

                m_processor.Size = m_size;

                m_finalProcessedImage = m_processor.BeginProcess();

                ImageCodecInfo jgpEncoder = GetEncoder(ImageFormat.Jpeg);
                System.Drawing.Imaging.Encoder myEncoder =
                    System.Drawing.Imaging.Encoder.Quality;

                EncoderParameters myEncoderParameters = new EncoderParameters(1);
                EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, m_jpegQuality);
                myEncoderParameters.Param[0] = myEncoderParameter;


                // Save the Image to the Output folder
                m_finalProcessedImage.Save(fldOutput.SelectedPath + "\\" + currentFile.Name, jgpEncoder, myEncoderParameters);

                // Dispose the Images
                m_finalProcessedImage.Dispose();

                m_currentImage.Dispose();

What the code i've written actually can do is resize your images to a specific percentage.

Answer 2

Thanks. I have played around with your code and it can probably solve my problem with a few modifications, so thank you (tack så mycket)!