CSharp examples for System.Drawing:Image Size
Generates a thumbnail of the bitmap. This is effectively a specialized resize function, which maintains the aspect ratio of the image while resizing it to ensure that both its width and height are within caller-specified maximums
using System.Net; using System.IO;/*from w ww . j av a 2 s . c om*/ using System.Drawing.Drawing2D; using System.Drawing.Imaging; using System.Drawing; using System; public class Main{ /// <summary> /// Generates a thumbnail of the bitmap. This is effectively a specialized /// resize function, which maintains the aspect ratio of the image while /// resizing it to ensure that both its width and height are within /// caller-specified maximums /// </summary> /// <param name="inputBmp">Bitmap for which to generate thumbnail</param> /// <param name="maxWidth">Maximum width of thumbnail</param> /// <param name="maxHeight">Maximum height of thumbnail</param> /// <returns>Thumbnail of inputBmp w/ the same aspect ratio, but /// width and height both less than or equal to the maximum limits</returns> public static Bitmap ThumbnailBitmap(Bitmap inputBmp, int maxWidth, int maxHeight) { //Compute the scaling factor that will scale the bitmap witdh //to the max width, and the other scaling factor that will scale //the bitmap height to the max height. //Apply the lower of the two, then if the other dimension is still //outside the caller-defined limits, compute the scaling factor //which will bring that dimension within the limits. double widthScaleFactor = (double)maxWidth / (double)inputBmp.Size.Width; double heightScaleFactor = (double)maxHeight / (double)inputBmp.Size.Height; double finalScaleFactor = 0; //Now pick the smaller scale factor if (widthScaleFactor < heightScaleFactor) { //If this scale factor doesn't bring the height //within the required maximum, combine this width //scale factor with an additional scaling factor //to take the height the rest of the way down if ((double)inputBmp.Size.Height * widthScaleFactor > maxHeight) { //Need to scale height further heightScaleFactor = (double)(maxHeight*widthScaleFactor) / (double)inputBmp.Size.Height; finalScaleFactor = widthScaleFactor * heightScaleFactor; } else { //Width scale factor brings both dimensions inline sufficiently finalScaleFactor = widthScaleFactor; } } else { //Else, height scale factor is smaller than width. //Apply the same logic as above, but with the roles of the width //and height scale factors reversed if ((double)inputBmp.Size.Width * heightScaleFactor > maxWidth) { //Need to scale height further widthScaleFactor = (double)(maxWidth*heightScaleFactor) / (double)inputBmp.Size.Width; finalScaleFactor = widthScaleFactor * heightScaleFactor; } else { //Height scale factor brings both dimensions inline sufficiently finalScaleFactor = heightScaleFactor; } } return ScaleBitmap(inputBmp, finalScaleFactor); } /// <summary> /// Scales a bitmap by a scale factor, growing or shrinking both axes independently, /// possibly changing the aspect ration /// </summary> /// <param name="inputBmp">Bitmap to scale</param> /// <param name="scaleFactor">Factor by which to scale</param> /// <returns>New bitmap containing image from inputBmp, scaled by the scale factor</returns> public static Bitmap ScaleBitmap(Bitmap inputBmp, double xScaleFactor, double yScaleFactor) { //Create a new bitmap object based on the input Bitmap newBmp = new Bitmap( (int)(inputBmp.Size.Width*xScaleFactor), (int)(inputBmp.Size.Height*yScaleFactor), PixelFormat.Format24bppRgb);//Graphics.FromImage doesn't like Indexed pixel format //Create a graphics object attached to the new bitmap Graphics newBmpGraphics = Graphics.FromImage(newBmp); //Set the interpolation mode to high quality bicubic //interpolation, to maximize the quality of the scaled image newBmpGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic; newBmpGraphics.ScaleTransform((float)xScaleFactor, (float)yScaleFactor); //Draw the bitmap in the graphics object, which will apply //the scale transform //Note that pixel units must be specified to ensure the framework doesn't attempt //to compensate for varying horizontal resolutions in images by resizing; in this case, //that's the opposite of what we want. Rectangle drawRect = new Rectangle(0, 0, inputBmp.Size.Width, inputBmp.Size.Height); newBmpGraphics.DrawImage(inputBmp, drawRect, drawRect, GraphicsUnit.Pixel); //Return the bitmap, as the operations on the graphics object //are applied to the bitmap newBmpGraphics.Dispose(); //newBmp will have a RawFormat of MemoryBmp because it was created //from scratch instead of being based on inputBmp. Since it it inconvenient //for the returned version of a bitmap to be of a different format, now convert //the scaled bitmap to the format of the source bitmap return ConvertBitmap(newBmp, inputBmp.RawFormat); } /// <summary> /// Scales a bitmap by a scale factor, growing or shrinking both axes while /// maintaining the original aspect ratio /// </summary> /// <param name="inputBmp">Bitmap to scale</param> /// <param name="scaleFactor">Factor by which to scale</param> /// <returns>New bitmap containing image from inputBmp, scaled by the scale factor</returns> public static Bitmap ScaleBitmap(Bitmap inputBmp, double scaleFactor) { return ScaleBitmap(inputBmp, scaleFactor, scaleFactor); } /// <summary>Converts a bitmap to another bitmap format, returning the new converted /// bitmap /// </summary> /// /// <param name="inputBmp">Bitmap to convert</param> /// <param name="destFormat">Bitmap format to convert to</param> /// /// <returns>A new bitmap object containing the input bitmap converted. /// If the destination format and the target format are the same, returns /// a clone of the destination bitmap.</returns> public static Bitmap ConvertBitmap(Bitmap inputBmp, System.Drawing.Imaging.ImageFormat destFormat) { //If the dest format matches the source format and quality/bpp not changing, just clone if (inputBmp.RawFormat.Equals(destFormat)) { return(Bitmap)inputBmp.Clone(); } //Create an in-memory stream which will be used to save //the converted image System.IO.Stream imgStream = new System.IO.MemoryStream(); //Save the bitmap out to the memory stream, using the format indicated by the caller inputBmp.Save(imgStream, destFormat); //At this point, imgStream contains the binary form of the //bitmap in the target format. All that remains is to load it //into a new bitmap object Bitmap destBitmap = new Bitmap(imgStream); //Free the stream //imgStream.Close(); //For some reason, the above causes unhandled GDI+ exceptions //when destBitmap.Save is called. Perhaps the bitmap object reads //from the stream asynchronously? return destBitmap; } /// <summary>Converts a bitmap to another bitmap format, returning the new converted /// bitmap /// </summary> /// /// <param name="inputBmp">Bitmap to convert</param> /// <param name="destMimeType">MIME type of format to convert to</param> /// /// <returns>A new bitmap object containing the input bitmap converted. /// If the destination format and the target format are the same, returns /// a clone of the destination bitmap.</returns> public static Bitmap ConvertBitmap(Bitmap inputBmp, String destMimeType) { return ConvertBitmap(inputBmp, ImageFormatFromMimeType(destMimeType)); } }