C# Image.GetThumbnailImage方法代码示例

        public static Image EnsureMaximumDimensions(Image image, int maxWidth, int maxHeight)
        {
            // Prevent using images internal thumbnail
            image.RotateFlip(RotateFlipType.Rotate180FlipNone);
            image.RotateFlip(RotateFlipType.Rotate180FlipNone);

            var aspectRatio = ((double)image.Width) / image.Height; //AR = L/A;

            int imageWidth = image.Width;
            int imageHeight = image.Height;

            if (imageWidth > maxWidth)
            {
                imageWidth = maxWidth;
                imageHeight = (int)(imageWidth / aspectRatio);
            }
            if (imageHeight > maxHeight)
            {
                imageHeight = maxHeight;
                imageWidth = (int)(imageHeight * aspectRatio);
            }

            if (image.Width != imageWidth || image.Height != imageHeight)
                return image.GetThumbnailImage(imageWidth, imageHeight, null, IntPtr.Zero);

            return image;
        }

        public static Image ScaleImage(Image ImageToScale, double ScaledToHeight, double ScaleToWidth)
        {
            //Hold the min value. Is it the height or the width - Figure out which is the minimum value...the width or the height. Keeps the ratio
            double ScalingValue = Math.Min((ScaleToWidth / ImageToScale.Width), (ScaledToHeight / ImageToScale.Height));

            //Set the final scaled width
            double ScaledWidth = (ScalingValue * ImageToScale.Width);

            //Set the final scaled height
            double ScaledHeight = (ScalingValue * ImageToScale.Height);

            //set the callback to the private method - ThumbnailCallback
            //just use a lamda since the method doesn't do anything
            Image.GetThumbnailImageAbort CallBackForConversion = new Image.GetThumbnailImageAbort(() =>
            {
                try
                {
                    return false;
                }
                catch (Exception)
                {
                    throw;
                }
            });

            //return the image that is going to be scaled
            return ImageToScale.GetThumbnailImage(Convert.ToInt32(ScaledWidth), Convert.ToInt32(ScaledHeight), CallBackForConversion, IntPtr.Zero);
        }

 public void newPBox_Click(object sender, EventArgs e)
 {
     string newIcon = ((PictureBox)sender).Tag.ToString();
       workingImage = Image.FromFile(newIcon);
       pbCurrentIcon.Image = workingImage.GetThumbnailImage(128, 128, null, new IntPtr());
       workingImage.Dispose();
       buttonTexture = newIcon;
 }

        public Image GetThumbNail( Image image, int new_width, int new_height )
        {
            Image.GetThumbnailImageAbort thumbnailCallback = new Image.GetThumbnailImageAbort( DummyThumbnailCallback );

            Image thumbnail = image.GetThumbnailImage( new_width, new_height, thumbnailCallback, IntPtr.Zero );

            return thumbnail;
        }

        /// <summary>
        /// create a thumbnail from the original image
        /// </summary>
        /// <param name="originalImage">the original image from which the thumbnail is created</param>
        /// <param name="imageHeight">the height of the thumbnail</param>
        /// <returns></returns>
        public static Image CreateThumbnail(Image originalImage, int imageHeight)
        {
            // create thumbnail
            float ratio = (float)originalImage.Width / originalImage.Height;
            int imageWidth = (int)(imageHeight * ratio);

            // set the thumbnail image
            Image thumbnailImage = originalImage.GetThumbnailImage(imageWidth, imageHeight,
                new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallback), IntPtr.Zero);

            return thumbnailImage;
        }

        /// <summary>
        ///     Gets a thumbnail image that represents the specified <paramref name="image"/>.
        /// </summary>
        /// <param name="image">The image.</param>
        /// <param name="width">The thumbnail image width.</param>
        /// <param name="height">The thumbnail image height.</param>
        /// <returns>The thumbnail image.</returns>
        public static Image GetThumbnail(Image image, int width, int height)
        {
            Check.Require<ArgumentNullException>(image != null, "image");
            Check.Require<ArgumentOutOfRangeException>(width > 0, "width");
            Check.Require<ArgumentOutOfRangeException>(height > 0, "height");

            return image.GetThumbnailImage(
                width,
                height,
                () => false,
                IntPtr.Zero);
        }

        public void UpdateImage(Image image, float thumbnailCoef)
        {
            int deltHeight = this.Height - this.pictureBox1.Height;
            int deltWidth = this.Width - this.pictureBox1.Width;

            Size thumbnailSize = new Size((int)(image.Width * thumbnailCoef), (int)(image.Height * thumbnailCoef));
            this.Size = new Size(thumbnailSize.Width + deltWidth, thumbnailSize.Height + deltHeight);                       
            
            System.Drawing.Image.GetThumbnailImageAbort myCallBack = new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallBack);

            Image thumbnail = image.GetThumbnailImage(thumbnailSize.Width, thumbnailSize.Height, myCallBack, IntPtr.Zero);//生成缩略图
            this.pictureBox1.Image = thumbnail;   
        }

        public static Image Scale(Image img, int maxWidth, int maxHeight, double scale)
        {
            if (img.Width > maxWidth || img.Height > maxHeight)
            {
                double scaleW, scaleH;

                scaleW = maxWidth / (double)img.Width;
                scaleH = maxHeight / (double)img.Height;

                scale = scaleW < scaleH ? scaleW : scaleH;
            }

            return img.GetThumbnailImage((int)(img.Width * scale), (int)(img.Height * scale), null, IntPtr.Zero);
        }

        /// <summary>
        /// Creates a thumbnail from the image provided, scaled down to the
        /// new height specified while keeping the aspect ratio
        /// </summary>
        /// <param name="fullImage">The image to replicate</param>
        /// <param name="newHeight">The new height to scale to</param>
        /// <returns>Returns a thumbnail Image</returns>
        public Image CreateThumbnail(Image fullImage, int newHeight)
        {
            Image.GetThumbnailImageAbort myCallback = new Image.GetThumbnailImageAbort(ThumbnailCallback);
            int newWidth;
            if (fullImage.Height > fullImage.Width)
            {
                newWidth = Convert.ToInt32(Math.Round((double) ((fullImage.Height/fullImage.Width)*newHeight)));
            }
            else
            {
                newWidth = Convert.ToInt32(Math.Round((double) ((fullImage.Width/fullImage.Height)*newHeight)));
            }

            return fullImage.GetThumbnailImage(newWidth, newHeight, myCallback, IntPtr.Zero);
        }

        public Negative(Image image, int width = 0, int height = 0)
        {
            if (width != height)
            {
                double ratio = width >= height ? (double)image.Height / image.Width : (double)image.Width / image.Height;
                if (width == 0)
                    width = (int)(height * ratio);
                if (height == 0)
                    height = (int)(width * ratio);
            }

            if (width == 0 && height == 0)
                _image = image;
            else _image = image.GetThumbnailImage(width, height, null, IntPtr.Zero);
        }

        public Image ResizeImage( Image fullsizeImage, int newWidth )
        {
            // Prevent using images internal thumbnail
            fullsizeImage.RotateFlip( System.Drawing.RotateFlipType.Rotate180FlipNone );
            fullsizeImage.RotateFlip( System.Drawing.RotateFlipType.Rotate180FlipNone );

            var newHeight = fullsizeImage.Height * newWidth / fullsizeImage.Width;
            
            var newImage = fullsizeImage.GetThumbnailImage( newWidth, newHeight, null, IntPtr.Zero );

            // Clear handle to original file so that we can overwrite it if necessary
            fullsizeImage.Dispose();

            // Save resized picture
            return newImage;
        }

 void populateScreen(string theme)
 {
     iconFiles.Clear();
       flThemeButtons.Controls.Clear();
       themePreview.Image = Image.FromFile(Path.Combine(Path.Combine(streamedMPMediaPath, "homebuttons"), theme + "themepreview.jpg"));
       iconList(theme);
       foreach (string icon in iconFiles)
       {
     PictureBox newPBox = new PictureBox();
     newPBox.Size = new Size(64, 64);
     workingImage = Image.FromFile(icon);
     newPBox.Image = workingImage.GetThumbnailImage(64, 64, null, new IntPtr());
     workingImage.Dispose();
     flThemeButtons.Controls.Add(newPBox);
       }
 }

 public static Image LowQualityScaledThumbnail(Image iImage,
     Int32 iMaxWidth,
     Int32 iMaxHeight)
 {
     Double pDblRatio = 0;
     if (iImage.Width > iImage.Height)
     {
         pDblRatio = (Double)iMaxWidth / iImage.Width;
     }
     else
     {
         pDblRatio = (Double)iMaxHeight / iImage.Height;
     }
     Double pDblRescaledWidth = iImage.Width * pDblRatio;
     Double pDblRescaledHeight = iImage.Height * pDblRatio;
     return (iImage.GetThumbnailImage((Int32)pDblRescaledWidth, (Int32)pDblRescaledHeight, null, IntPtr.Zero));
 }

        internal void ResizeImage(Image source, Stream stream)
        {
            if (source == null)
                throw new ArgumentNullException("source");

            Size size = DetermineScalingSize(source, _widthThreshold, _heightThreshold);

            ImageConverter imageConverter = new ImageConverter();

            using (Image resized = source.GetThumbnailImage(size.Width, size.Height, () => false, IntPtr.Zero))
            {
                ImageCodecInfo jpgEncoder = GetEncoderInfo("image/jpeg");
                using (EncoderParameters encoderParameters = GetEncodeParamaters(_compression))
                {
                    resized.Save(stream, jpgEncoder, encoderParameters);
                }
            }
        }

        private void LoadImage(Image image)
        {
            this.CalculateTextSize();
            _szText.Height += 4;
            this.Height += _szText.Height + GAP_SIZE_SHADOW;
            this.Width += GAP_SIZE_SHADOW;

            Rectangle rc = this.ClientRectangle;
            _rcClient = new Rectangle(rc.Left + GAP_OFFSET_SHADOW, rc.Top + GAP_OFFSET_SHADOW,
                                      rc.Width - GAP_SIZE_SHADOW, rc.Height - GAP_SIZE_SHADOW);

            using (image)
            {
                _imageThumbnail = image.GetThumbnailImage(_rcClient.Width - GAP_SIZE,
                                                        _rcClient.Height - _szText.Height - GAP_SIZE,
                                                        null, IntPtr.Zero);
            }
        }