调整图像大小- WIC与GDI

Question

编辑:从那以后，我发现这些实现对服务器端场景都没有任何好处:它们不受微软的支持。所以别再用它们了！

因此，我在下面提供了两个独立的实现。我想我已经安装了(WIC)实现。

一些评论：

• GDI的实现似乎比WIC @ 0.26s/photo @0.14s/Photo还要快)
• 当多线程，GDI下降到~0.10s/照片时，WIC实现没有看到任何性能提高。
• 服务器端处理只支持WIC，但是如果它不支持mutli线程，那么它就不能很好地扩展。
• 运行在i7上，这张照片是由奥林巴斯迪迪卡姆创建的典型的1.2MB图像
• 我从http://weblogs.asp.net/bleroy/archive/2009/12/10/resizing-images-from-the-server-using-wpf-wic-instead-of-gdi.aspx那里得到灵感

有人能看到明显的东西吗？

using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.IO;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace Mrwa.Bms.Common.Imaging
{
    /// <summary>
    /// Generates JPEG image previews for any supplied .NET image supported files
    /// </summary>
    /// <remarks>
    /// WIC = Windows Imaging Component
    /// http://weblogs.asp.net/bleroy/archive/2009/12/10/resizing-images-from-the-server-using-wpf-wic-instead-of-gdi.aspx
    /// </remarks>
    public class WicImagePreviewGenerator : IImagePreviewGenerator
    {
        private const int ScreenDpi = 96;
        private BitmapFrame _imageFrame;

        public WicImagePreviewGenerator(Stream stream)
        {
            Contract.Requires(stream != null);

            try
            {
                if (stream.CanSeek) stream.Seek(0, SeekOrigin.Begin);

                var decoder = BitmapDecoder.Create(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
                _imageFrame = decoder.Frames[0];
            }
            catch (NotSupportedException ex)
            {
                throw new ArgumentException("The image is corrupt.", "stream", ex);
            }
        }

        public ImagePreviewGeneratorDto Generate(
            int pixelSize, int jpegQuality = 80, int dpi = 72,
            ImagePreviewGeneratorResizeQualityEnum resizeQuality = ImagePreviewGeneratorResizeQualityEnum.HighQuality)
        {
            int previewWidth;
            int previewHeight;
            CalculateDimensions(pixelSize, out previewWidth, out previewHeight);

            // create a new target drawing canvas
            var width = (int) (previewWidth*(ScreenDpi/(decimal) dpi));
            var height = (int) (previewHeight*(ScreenDpi/(decimal) dpi));
            var drawing = new ImageDrawing(
                _imageFrame,
                new Rect(0, 0, width, height));

            var group = new DrawingGroup();
            RenderOptions.SetBitmapScalingMode(group, GetScalingMode(resizeQuality));
            group.Children.Add(drawing);

            // generate the preview image frame
            BitmapFrame previewFrame;
            var previewVisual = new DrawingVisual();
            using (var previewContext = previewVisual.RenderOpen())
            {
                previewContext.DrawDrawing(group);
                previewContext.Close();

                var previewBitmap = new RenderTargetBitmap(
                    previewWidth, previewHeight,
                    dpi, dpi,
                    PixelFormats.Default);
                previewBitmap.Render(previewVisual);
                previewFrame = BitmapFrame.Create(previewBitmap);
            }

            // generate the result as a JPG
            using (var content = new MemoryStream())
            {
                var previewEncoder = new JpegBitmapEncoder { QualityLevel = jpegQuality };
                previewEncoder.Frames.Add(previewFrame);
                previewEncoder.Save(content);
                content.Flush();

                return new ImagePreviewGeneratorDto
                    {
                        Preview = content.ToArray(),
                        Width = previewWidth,
                        Height = previewHeight
                    };
            }
        }

        // not used - retained for reference only
        public IEnumerable<byte> GenerateOptimised(int pixelSize, int jpegQuality = 80)
        {
            int previewWidth;
            int previewHeight;
            CalculateDimensions(pixelSize, out previewWidth, out previewHeight);

            var transform = new TransformedBitmap(
                _imageFrame, new ScaleTransform(previewWidth, previewHeight, 0, 0));

            var previewFrame = BitmapFrame.Create(transform);

            // generate the result as a JPG
            using (var result = new MemoryStream())
            {
                var previewEncoder = new JpegBitmapEncoder { QualityLevel = jpegQuality };
                previewEncoder.Frames.Add(previewFrame);
                previewEncoder.Save(result);

                return result.ToArray();
            }
        }

        private static BitmapScalingMode GetScalingMode(ImagePreviewGeneratorResizeQualityEnum previewQuality)
        {
            switch (previewQuality)
            {
                case ImagePreviewGeneratorResizeQualityEnum.HighQuality:
                    return BitmapScalingMode.HighQuality;
                case ImagePreviewGeneratorResizeQualityEnum.HighSpeed:
                    return BitmapScalingMode.LowQuality;
                default:
                    throw new NotSupportedException("Invalid preview quality specified.");
            }
        }

        private void CalculateDimensions(int pixelSize, out int width, out int height)
        {
            var originalWidth = _imageFrame.PixelWidth;
            var originalHeight = _imageFrame.PixelHeight;

            // scale: reduce the longest side down to 'X' pixels and maintain the aspect ratio
            if (originalWidth <= pixelSize && originalHeight <= pixelSize)
            {
                width = originalWidth;
                height = originalHeight;
            }
            else if (originalWidth >= originalHeight)
            {
                width = pixelSize;
                height = (int)((pixelSize / (decimal)originalWidth) * originalHeight);
            }
            else
            {
                width = (int)((pixelSize / (decimal)originalHeight) * originalWidth);
                height = pixelSize;
            }
        }

        #region IDisposable

        private bool _disposed;

        ~WicImagePreviewGenerator()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (_disposed) return;
            if (disposing)
            {
                // free managed resources
                _imageFrame = null;
            }

            // free unmanaged resources

            _disposed = true;
        }

        #endregion
    }
}

using System;
using System.Diagnostics.Contracts;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;

namespace Mrwa.Bms.Common.Imaging
{
    /// <summary>
    /// Generates JPEG image previews for any supplied .NET image supported files
    /// </summary>
    /// <remarks>
    /// Feel free to use this Client side.  Not officially supported for back-end scenarios.
    /// </remarks>
    public class GdiPlusImagePreviewGenerator : IImagePreviewGenerator
    {
        private Image _image;

        public GdiPlusImagePreviewGenerator(Stream stream)
        {
            Contract.Requires(stream != null);

            try
            {
                if (stream.CanSeek) stream.Seek(0, SeekOrigin.Begin);
                _image = Image.FromStream(stream);
            }
            catch (ArgumentException ex)
            {
                throw new ArgumentException("The image is corrupt.", "stream", ex);
            }
        }

        private void CalculateDimensions(int pixelSize, out int width, out int height)
        {
            var originalWidth = _image.Width;
            var originalHeight = _image.Height;

            // scale: reduce the longest side down to 'X' pixels and maintain the aspect ratio
            if (originalWidth <= pixelSize && originalHeight <= pixelSize)
            {
                width = originalWidth;
                height = originalHeight;
            }
            else if (originalWidth >= originalHeight)
            {
                width = pixelSize;
                height = (int)((pixelSize / (decimal)originalWidth) * originalHeight);
            }
            else
            {
                width = (int)((pixelSize / (decimal)originalHeight) * originalWidth);
                height = pixelSize;
            }
        }

        /// <remarks>
        /// Not changing the colour depth; apparently the conversion can be quite poor
        /// Don't forget to dispose of the stream
        /// </remarks>
        public ImagePreviewGeneratorDto Generate(
            int pixelSize, int jpegQuality = 80, int dpi = 72,
            ImagePreviewGeneratorResizeQualityEnum resizeQuality = ImagePreviewGeneratorResizeQualityEnum.HighQuality)
        {
            int previewWidth;
            int previewHeight;
            CalculateDimensions(pixelSize, out previewWidth, out previewHeight);

            // resize the image (in terms of pixels) and standardise the DPI
            using (var previewImage = new Bitmap(previewWidth, previewHeight))
            {
                previewImage.SetResolution(dpi, dpi);
                using (var graphics = Graphics.FromImage(previewImage))
                {
                    switch (resizeQuality)
                    {
                        case ImagePreviewGeneratorResizeQualityEnum.HighQuality:
                            graphics.SmoothingMode = SmoothingMode.HighQuality;
                            graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
                            graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
                            break;
                        case ImagePreviewGeneratorResizeQualityEnum.HighSpeed:
                            graphics.SmoothingMode = SmoothingMode.HighSpeed;
                            graphics.InterpolationMode = InterpolationMode.Low;
                            graphics.PixelOffsetMode = PixelOffsetMode.HighSpeed;
                            break;
                        default:
                            throw new NotSupportedException("Invalid Preview Quality Enum supplied.");
                    }

                    graphics.DrawImage(_image, new Rectangle(0, 0, previewWidth, previewHeight));
                }

                // convert to a JPG and reduce the quality
                using (var content = new MemoryStream())
                {
                    var jpegEncoder = GetEncoder(ImageFormat.Jpeg);

                    previewImage.Save(content, jpegEncoder,
                        new EncoderParameters
                        {
                            Param = new[] { new EncoderParameter(Encoder.Quality, jpegQuality) },
                        });
                    content.Flush();

                    // return the stream
                    return new ImagePreviewGeneratorDto
                        {
                            Preview = content.ToArray(),
                            Width = previewWidth,
                            Height = previewHeight
                        };
                }
            }
        }

        private static ImageCodecInfo GetEncoder(ImageFormat format)
        {
            var codecs = ImageCodecInfo.GetImageDecoders();
            return codecs.FirstOrDefault(codec => codec.FormatID == format.Guid);
        }

        #region IDisposable

        private bool _disposed;

        ~GdiPlusImagePreviewGenerator()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (_disposed) return;
            if (disposing)
            {
                // free managed resources
                if (_image != null)
                {
                    _image.Dispose();
                    _image = null;
                }
            }

            // free unmanaged resources

            _disposed = true;
        }

        #endregion
    }
}

Answer 1

我注意到BitmapCacheOption.None在处理批处理时大大提高了性能。