/// <summary> /// Generates a thumbnail of the source image based on parameters.</summary> /// <remarks> /// <p>Thumbnail width or height must be greater than 0. Otherwise an empty image /// is generated.</p> /// <p>When ImageScaleMode.PreserveRatioNoFill used and both dimensions are set, /// if aspect ratio of source image and thumbnail doesn't match, thumbnail's horizontal or vertical /// size may be different than requested one. In, PreserveRatioWithFill mode thumbnail size will /// be at requested size but empty parts are filled with a solid color.</p></remarks> /// <param name="image"> /// Image object to generate thumbnail for (required)</param> /// <param name="thumbWidth"> /// Thumbnail width. If 0, width is calculated by source aspect ratio. Only one of /// width or height can be zero.</param> /// <param name="thumbHeight"> /// Thumbnail height. If 0, height is calculated by source aspect ratio. Only one of /// width or height can be zero.</param> /// <param name="mode"> /// Thumbnail generation mode. It is only important when both dimensions are specified and /// source aspect ratio is different than thumbnail (see <see cref="ImageScaleMode"/>).</param> /// <param name="backgroundColor"> /// Specifies fill color for PreserveRatioWithFill mode.</param> /// <returns> /// Generated thumbnail image. Should be disposed by caller.</returns> public static Image Generate(Image image, int thumbWidth, int thumbHeight, ImageScaleMode mode, Color?backgroundColor = null, bool inplace = false) { if (image == null) { throw new ArgumentNullException("image"); } int imageWidth = image.Width; int imageHeight = image.Height; // if image or thumb width and height is zero, return an empty image if (imageWidth <= 0 || imageHeight <= 0 || (thumbWidth <= 0 && thumbHeight <= 0)) { return(GenerateEmptyBitmap(imageWidth, imageHeight, backgroundColor ?? Color.White)); } // if thumb width is zero, thumb height is not zero // so calculate width by aspect ratio, do similar // if thumb height is zero. for both states, aspect // ratio of source and thumb will be same if (thumbWidth == 0) { thumbWidth = Convert.ToInt32(imageWidth * thumbHeight / ((double)imageHeight)); mode = ImageScaleMode.StretchToFit; } else if (thumbHeight == 0) { thumbHeight = Convert.ToInt32(imageHeight * thumbWidth / ((double)imageWidth)); mode = ImageScaleMode.StretchToFit; } var resizeMode = mode switch { ImageScaleMode.PreserveRatioNoFill => ResizeMode.Max, ImageScaleMode.PreserveRatioWithFill => ResizeMode.Pad, ImageScaleMode.CropSourceImage => ResizeMode.Crop, _ => ResizeMode.Stretch, }; void operation(IImageProcessingContext x) { x.Resize(new ResizeOptions { Mode = resizeMode, Size = new Size(thumbWidth, thumbHeight), PremultiplyAlpha = false }); } if (inplace) { image.Mutate(operation); return(image); } return(image.Clone(operation)); }
public ColumnItemData() { Type = ColumnItemType.NodeTextBox; DataPropertyName = string.Empty; EditEnabled = false; IncrementalSearchEnabled = false; LeftMargin = 0; HorizontalAlign = HorizontalAlignment.Left; ImageScaleMode = ImageScaleMode.Clip; }
public ColumnItemData() { Type = ColumnItemType.NodeTextBox; DataPropertyName = string.Empty; EditEnabled = false; IncrementalSearchEnabled = false; LeftMargin = 0; HorizontalAlign = HorizontalAlignment.Left; ImageScaleMode = ImageScaleMode.Clip; }
public ImageUploadEditorAttribute(string originalNameProperty = null, int minBytes = 0, int maxBytes = 0, int minWidth = 0, int maxWidth = 0, int minHeight = 0, int maxHeight = 0, bool allowFlash = false, int scaleWidth = 0, int scaleHeight = 0, bool scaleSmaller = true, ImageScaleMode scaleMode = ImageScaleMode.CropSourceImage, string thumbSizes = null, ImageScaleMode thumbMode = ImageScaleMode.CropSourceImage, int thumbQuality = 0) : base("ImageUpload") { OriginalNameProperty = originalNameProperty; MinBytes = minBytes; MaxBytes = maxBytes; MinWidth = minWidth; MaxWidth = maxWidth; MinHeight = minHeight; MaxHeight = maxHeight; ScaleWidth = scaleWidth; ScaleHeight = scaleHeight; ScaleSmaller = scaleSmaller; ScaleMode = scaleMode; ThumbSizes = thumbSizes; ThumbMode = thumbMode; ThumbQuality = ThumbQuality; }
/// <summary> /// Generates a thumbnail of the source image based on parameters.</summary> /// <remarks> /// <p>Thumbnail width or height must be greater than 0. Otherwise an empty image /// is generated.</p> /// <p>When ImageScaleMode.PreserveRatioNoFill used and both dimensions are set, /// if aspect ratio of source image and thumbnail doesn't match, thumbnail's horizontal or vertical /// size may be different than requested one. In, PreserveRatioWithFill mode thumbnail size will /// be at requested size but empty parts are filled with a solid color.</p></remarks> /// <param name="image"> /// Image object to generate thumbnail for (required)</param> /// <param name="thumbWidth"> /// Thumbnail width. If 0, width is calculated by source aspect ratio. Only one of /// width or height can be zero.</param> /// <param name="thumbHeight"> /// Thumbnail height. If 0, height is calculated by source aspect ratio. Only one of /// width or height can be zero.</param> /// <param name="mode"> /// Thumbnail generation mode. It is only important when both dimensions are specified and /// source aspect ratio is different than thumbnail (see <see cref="ImageScaleMode"/>).</param> /// <param name="backgroundColor"> /// Specifies fill color for PreserveRatioWithFill mode.</param> /// <returns> /// Generated thumbnail image. Should be disposed by caller.</returns> public static Image Generate(Image image, int thumbWidth, int thumbHeight, ImageScaleMode mode, Color backgroundColor, float xDPI = 0, float yDPI = 0) { if (image == null) throw new ArgumentNullException("image"); int imageWidth = image.Width; int imageHeight = image.Height; // if image or thumb width and height is zero, return an empty image if (imageWidth <= 0 || imageHeight <= 0 || (thumbWidth <= 0 && thumbHeight <= 0)) { return GenerateEmptyBitmap(thumbWidth, thumbHeight, backgroundColor); } // calculate thumb width / source image width double horizontalScale = ((double)thumbWidth) / ((double)imageWidth); // calculate thumb height / source image height double verticalScale = ((double)thumbHeight) / ((double)imageHeight); // if thumb width is zero, thumb height is not zero // so calculate width by aspect ratio, do similar // if thumb height is zero. for both states, aspect // ratio of source and thumb will be same if (thumbWidth == 0) { thumbWidth = Convert.ToInt32((double)imageWidth * verticalScale); horizontalScale = verticalScale; mode = ImageScaleMode.StretchToFit; } else if (thumbHeight == 0) { thumbHeight = Convert.ToInt32((double)imageHeight * horizontalScale); verticalScale = horizontalScale; mode = ImageScaleMode.StretchToFit; } // position to generate thumb in thumbnail image, initially based on thumbWidth, thumbHeight Rectangle thumbRect = new Rectangle(0, 0, thumbWidth, thumbHeight); // source rectangle to use in source image, initially all of source image Rectangle imageRect = new Rectangle(0, 0, image.Width, image.Height); // At this point, if mode is CropSourceImage, check to see is this mode is applicable, // as if horizontal and vertical ratios are very close, when StretchToFit is used // instead of CropSourceImage, someone looking at the generated thumb won't notice difference, // because AspectRatio mismatch is like one in a million. // If thumbWidth or thumbHeight is zero, CropSourceImage won't be used if (mode == ImageScaleMode.CropSourceImage && Math.Abs(horizontalScale - verticalScale) >= 0.0001 && horizontalScale != 0 && verticalScale != 0) { int cropSize; // if thubmnails scale to source image horizontally, is bigger than vertical scale, // we take all of the source image vertically, and central part of it horizontally // otherwise take all of the source image horizontally, and central part of it vertically if (horizontalScale <= verticalScale) { cropSize = Convert.ToInt32((double)thumbWidth / verticalScale); imageRect.X = (imageRect.Width - cropSize) / 2; imageRect.Width = cropSize; } else { cropSize = Convert.ToInt32((double)thumbHeight / horizontalScale); imageRect.Y = (imageRect.Height - cropSize) / 2; imageRect.Height = cropSize; } } else if ( mode == ImageScaleMode.PreserveRatioWithFill || mode == ImageScaleMode.PreserveRatioNoFill) { // In PreserveRatioWithFill ve PreserveRatioNoFill modes, // scaling is performed without changing aspect ratio. // As there will be horizontal or vertical spaces, in WithFill mode, // they are filled with a solid color, while in NoFill mode // thumbWidth, thumbHeight are decreased as size of the space if (horizontalScale <= verticalScale) { thumbRect.Height = Convert.ToInt32(horizontalScale * imageHeight); if (mode == ImageScaleMode.PreserveRatioWithFill) thumbRect.Y = (thumbHeight - thumbRect.Height) / 2; else thumbHeight = thumbRect.Height; } else { thumbRect.Width = Convert.ToInt32(verticalScale * imageWidth); if (mode == ImageScaleMode.PreserveRatioWithFill) thumbRect.X = (thumbWidth - thumbRect.Width) / 2; else thumbWidth = thumbRect.Width; } } // create a 24 bit thumbnail image Bitmap thumb = new Bitmap(thumbWidth, thumbHeight, PixelFormat.Format24bppRgb); try { if ((xDPI != 0 && (thumb.HorizontalResolution != xDPI)) || (yDPI != 0 && (thumb.VerticalResolution != yDPI))) { thumb.SetResolution(xDPI, yDPI); } using (Graphics g = Graphics.FromImage(thumb)) { // high quality parameters g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic; g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality; g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality; g.Clear(backgroundColor); g.DrawImage(image, thumbRect, imageRect, GraphicsUnit.Pixel); } } catch { // dispose generated image if any errors occur thumb.Dispose(); throw; } return thumb; }
/// <summary> /// Generates a thumbnail of the source image based on parameters.</summary> /// <remarks> /// <p>Thumbnail width or height must be greater than 0. Otherwise an empty image /// is generated.</p> /// <p>When ImageScaleMode.PreserveRatioNoFill used and both dimensions are set, /// if aspect ratio of source image and thumbnail doesn't match, thumbnail's horizontal or vertical /// size may be different than requested one. In, PreserveRatioWithFill mode thumbnail size will /// be at requested size but empty parts are filled with a solid color.</p></remarks> /// <param name="image"> /// Image object to generate thumbnail for (required)</param> /// <param name="thumbWidth"> /// Thumbnail width. If 0, width is calculated by source aspect ratio. Only one of /// width or height can be zero.</param> /// <param name="thumbHeight"> /// Thumbnail height. If 0, height is calculated by source aspect ratio. Only one of /// width or height can be zero.</param> /// <param name="mode"> /// Thumbnail generation mode. It is only important when both dimensions are specified and /// source aspect ratio is different than thumbnail (see <see cref="ImageScaleMode"/>).</param> /// <param name="backgroundColor"> /// Specifies fill color for PreserveRatioWithFill mode.</param> /// <returns> /// Generated thumbnail image. Should be disposed by caller.</returns> public static Image Generate(Image image, int thumbWidth, int thumbHeight, ImageScaleMode mode, Color backgroundColor, float xDPI = 0, float yDPI = 0) { if (image == null) { throw new ArgumentNullException("image"); } int imageWidth = image.Width; int imageHeight = image.Height; // if image or thumb width and height is zero, return an empty image if (imageWidth <= 0 || imageHeight <= 0 || (thumbWidth <= 0 && thumbHeight <= 0)) { return(GenerateEmptyBitmap(thumbWidth, thumbHeight, backgroundColor)); } // calculate thumb width / source image width double horizontalScale = thumbWidth / ((double)imageWidth); // calculate thumb height / source image height double verticalScale = thumbHeight / ((double)imageHeight); // if thumb width is zero, thumb height is not zero // so calculate width by aspect ratio, do similar // if thumb height is zero. for both states, aspect // ratio of source and thumb will be same if (thumbWidth == 0) { thumbWidth = Convert.ToInt32(imageWidth * verticalScale); horizontalScale = verticalScale; mode = ImageScaleMode.StretchToFit; } else if (thumbHeight == 0) { thumbHeight = Convert.ToInt32(imageHeight * horizontalScale); verticalScale = horizontalScale; mode = ImageScaleMode.StretchToFit; } // position to generate thumb in thumbnail image, initially based on thumbWidth, thumbHeight Rectangle thumbRect = new Rectangle(0, 0, thumbWidth, thumbHeight); // source rectangle to use in source image, initially all of source image Rectangle imageRect = new Rectangle(0, 0, image.Width, image.Height); // At this point, if mode is CropSourceImage, check to see is this mode is applicable, // as if horizontal and vertical ratios are very close, when StretchToFit is used // instead of CropSourceImage, someone looking at the generated thumb won't notice difference, // because AspectRatio mismatch is like one in a million. // If thumbWidth or thumbHeight is zero, CropSourceImage won't be used if (mode == ImageScaleMode.CropSourceImage && Math.Abs(horizontalScale - verticalScale) >= 0.0001 && horizontalScale != 0 && verticalScale != 0) { int cropSize; // if thubmnails scale to source image horizontally, is bigger than vertical scale, // we take all of the source image vertically, and central part of it horizontally // otherwise take all of the source image horizontally, and central part of it vertically if (horizontalScale <= verticalScale) { cropSize = Convert.ToInt32(thumbWidth / verticalScale); imageRect.X = (imageRect.Width - cropSize) / 2; imageRect.Width = cropSize; } else { cropSize = Convert.ToInt32(thumbHeight / horizontalScale); imageRect.Y = (imageRect.Height - cropSize) / 2; imageRect.Height = cropSize; } } else if ( mode == ImageScaleMode.PreserveRatioWithFill || mode == ImageScaleMode.PreserveRatioNoFill) { // In PreserveRatioWithFill ve PreserveRatioNoFill modes, // scaling is performed without changing aspect ratio. // As there will be horizontal or vertical spaces, in WithFill mode, // they are filled with a solid color, while in NoFill mode // thumbWidth, thumbHeight are decreased as size of the space if (horizontalScale <= verticalScale) { thumbRect.Height = Convert.ToInt32(horizontalScale * imageHeight); if (mode == ImageScaleMode.PreserveRatioWithFill) { thumbRect.Y = (thumbHeight - thumbRect.Height) / 2; } else { thumbHeight = thumbRect.Height; } } else { thumbRect.Width = Convert.ToInt32(verticalScale * imageWidth); if (mode == ImageScaleMode.PreserveRatioWithFill) { thumbRect.X = (thumbWidth - thumbRect.Width) / 2; } else { thumbWidth = thumbRect.Width; } } } // create a 24 bit thumbnail image Bitmap thumb = new Bitmap(thumbWidth, thumbHeight, PixelFormat.Format24bppRgb); try { if ((xDPI != 0 && (thumb.HorizontalResolution != xDPI)) || (yDPI != 0 && (thumb.VerticalResolution != yDPI))) { thumb.SetResolution(xDPI, yDPI); } using Graphics g = Graphics.FromImage(thumb); // high quality parameters g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic; g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality; g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality; g.Clear(backgroundColor); g.DrawImage(image, thumbRect, imageRect, GraphicsUnit.Pixel); } catch { // dispose generated image if any errors occur thumb.Dispose(); throw; } return(thumb); }