Wie drehe ich ein Bild in WinForms?

Ich möchte ein Bild in meiner Anwendung haben, das ich drehen kann, um Richtungen wie die Windrichtung anzuzeigen. Oder auch die Zeit. Welchen Code verwende ich, um das Bild zu drehen? Vielen Dank

Update: Ich verwende .NET 2.0, Windows 2000, VS C # 2005

Hier ist eine Methode, mit der Sie ein Bild in C # drehen können:

///  /// method to rotate an image either clockwise or counter-clockwise ///  /// the image to be rotated /// the angle (in degrees). /// NOTE: /// Positive values will rotate clockwise /// negative values will rotate counter-clockwise ///  ///  public static Image RotateImage(Image img, float rotationAngle) { //create an empty Bitmap image Bitmap bmp = new Bitmap(img.Width, img.Height); //turn the Bitmap into a Graphics object Graphics gfx = Graphics.FromImage(bmp); //now we set the rotation point to the center of our image gfx.TranslateTransform((float)bmp.Width / 2, (float)bmp.Height / 2); //now rotate the image gfx.RotateTransform(rotationAngle); gfx.TranslateTransform(-(float)bmp.Width / 2, -(float)bmp.Height / 2); //set the InterpolationMode to HighQualityBicubic so to ensure a high //quality image once it is transformed to the specified size gfx.InterpolationMode = InterpolationMode.HighQualityBicubic; //now draw our new image onto the graphics object gfx.DrawImage(img, new Point(0, 0)); //dispose of our Graphics object gfx.Dispose(); //return the image return bmp; } 

Einfache Methode:

 public Image RotateImage(Image img) { var bmp = new Bitmap(img); using (Graphics gfx = Graphics.FromImage(bmp)) { gfx.Clear(Color.White); gfx.DrawImage(img, 0, 0, img.Width, img.Height); } bmp.RotateFlip(RotateFlipType.Rotate270FlipNone); return bmp; } 

Dies ist ein alter Thread, und es gibt einige andere Threads über C # WinForms Image Rotation, aber jetzt, da ich meine Lösung gefunden habe, denke ich, das ist so ein guter Ort, um es als irgendein zu posten.

  ///  /// Method to rotate an Image object. The result can be one of three cases: /// - upsizeOk = true: output image will be larger than the input, and no clipping occurs /// - upsizeOk = false & clipOk = true: output same size as input, clipping occurs /// - upsizeOk = false & clipOk = false: output same size as input, image reduced, no clipping /// /// A background color must be specified, and this color will fill the edges that are not /// occupied by the rotated image. If color = transparent the output image will be 32-bit, /// otherwise the output image will be 24-bit. /// /// Note that this method always returns a new Bitmap object, even if rotation is zero - in /// which case the returned object is a clone of the input object. ///  /// input Image object, is not modified /// angle of rotation, in degrees /// see comments above /// see comments above, not used if upsizeOk = true /// color to fill exposed parts of the background /// new Bitmap object, may be larger than input image public static Bitmap RotateImage(Image inputImage, float angleDegrees, bool upsizeOk, bool clipOk, Color backgroundColor) { // Test for zero rotation and return a clone of the input image if (angleDegrees == 0f) return (Bitmap)inputImage.Clone(); // Set up old and new image dimensions, assuming upsizing not wanted and clipping OK int oldWidth = inputImage.Width; int oldHeight = inputImage.Height; int newWidth = oldWidth; int newHeight = oldHeight; float scaleFactor = 1f; // If upsizing wanted or clipping not OK calculate the size of the resulting bitmap if (upsizeOk || !clipOk) { double angleRadians = angleDegrees * Math.PI / 180d; double cos = Math.Abs(Math.Cos(angleRadians)); double sin = Math.Abs(Math.Sin(angleRadians)); newWidth = (int)Math.Round(oldWidth * cos + oldHeight * sin); newHeight = (int)Math.Round(oldWidth * sin + oldHeight * cos); } // If upsizing not wanted and clipping not OK need a scaling factor if (!upsizeOk && !clipOk) { scaleFactor = Math.Min((float)oldWidth / newWidth, (float)oldHeight / newHeight); newWidth = oldWidth; newHeight = oldHeight; } // Create the new bitmap object. If background color is transparent it must be 32-bit, // otherwise 24-bit is good enough. Bitmap newBitmap = new Bitmap(newWidth, newHeight, backgroundColor == Color.Transparent ? PixelFormat.Format32bppArgb : PixelFormat.Format24bppRgb); newBitmap.SetResolution(inputImage.HorizontalResolution, inputImage.VerticalResolution); // Create the Graphics object that does the work using (Graphics graphicsObject = Graphics.FromImage(newBitmap)) { graphicsObject.InterpolationMode = InterpolationMode.HighQualityBicubic; graphicsObject.PixelOffsetMode = PixelOffsetMode.HighQuality; graphicsObject.SmoothingMode = SmoothingMode.HighQuality; // Fill in the specified background color if necessary if (backgroundColor != Color.Transparent) graphicsObject.Clear(backgroundColor); // Set up the built-in transformation matrix to do the rotation and maybe scaling graphicsObject.TranslateTransform(newWidth / 2f, newHeight / 2f); if (scaleFactor != 1f) graphicsObject.ScaleTransform(scaleFactor, scaleFactor); graphicsObject.RotateTransform(angleDegrees); graphicsObject.TranslateTransform(-oldWidth / 2f, -oldHeight / 2f); // Draw the result graphicsObject.DrawImage(inputImage, 0, 0); } return newBitmap; } 

Dies ist das Ergebnis vieler Inspirationsquellen, hier bei StackOverflow und anderswo. Naveens Antwort auf diesen Thread war besonders hilfreich.

Ich habe diesen Artikel gefunden

  ///  /// Creates a new Image containing the same image only rotated ///  /// The  to rotate /// The position to rotate from. /// The amount to rotate the image, clockwise, in degrees /// A new  of the same size rotated. /// Thrown if  /// is null. public static Bitmap RotateImage(Image image, PointF offset, float angle) { if (image == null) throw new ArgumentNullException("image"); //create a new empty bitmap to hold rotated image Bitmap rotatedBmp = new Bitmap(image.Width, image.Height); rotatedBmp.SetResolution(image.HorizontalResolution, image.VerticalResolution); //make a graphics object from the empty bitmap Graphics g = Graphics.FromImage(rotatedBmp); //Put the rotation point in the center of the image g.TranslateTransform(offset.X, offset.Y); //rotate the image g.RotateTransform(angle); //move the image back g.TranslateTransform(-offset.X, -offset.Y); //draw passed in image onto graphics object g.DrawImage(image, new PointF(0, 0)); return rotatedBmp; } 

Ich habe eine einfache class für rotierendes Bild geschrieben. Sie müssen nur Bild und Drehwinkel in Grad eingeben. Der angular muss zwischen -90 und +90 liegen.

 public class ImageRotator { private readonly Bitmap image; public Image OriginalImage { get { return image; } } private ImageRotator(Bitmap image) { this.image = image; } private double GetRadian(double degree) { return degree * Math.PI / (double)180; } private Size CalculateSize(double angle) { double radAngle = GetRadian(angle); int width = (int)(image.Width * Math.Cos(radAngle) + image.Height * Math.Sin(radAngle)); int height = (int)(image.Height * Math.Cos(radAngle) + image.Width * Math.Sin(radAngle)); return new Size(width, height); } private PointF GetTopCoordinate(double radAngle) { Bitmap image = CurrentlyViewedMappedImage.BitmapImage; double topX = 0; double topY = 0; if (radAngle > 0) { topX = image.Height * Math.Sin(radAngle); } if (radAngle < 0) { topY = image.Width * Math.Sin(-radAngle); } return new PointF((float)topX, (float)topY); } public Bitmap RotateImage(double angle) { SizeF size = CalculateSize(radAngle); Bitmap rotatedBmp = new Bitmap((int)size.Width, (int)size.Height); Graphics g = Graphics.FromImage(rotatedBmp); g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic; g.CompositingQuality = CompositingQuality.HighQuality; g.SmoothingMode = SmoothingMode.HighQuality; g.PixelOffsetMode = PixelOffsetMode.HighQuality; g.TranslateTransform(topPoint.X, topPoint.Y); g.RotateTransform(GetDegree(radAngle)); g.DrawImage(image, new RectangleF(0, 0, size.Width, size.Height)); g.Dispose(); return rotatedBmp; } public static class Builder { public static ImageRotator CreateInstance(Image image) { ImageRotator rotator = new ImageRotator(image as Bitmap); return rotator; } } } 

Rotierendes Bild ist eine Sache, richtige Bildgrenzen in einer anderen. Hier ist ein Code, der jedem helfen kann. Ich habe dies vor einiger Zeit auf der Suche im Internet erstellt.

  ///  /// Rotates image in radian angle ///  ///  /// in radian /// Because of rotation returned bitmap can have different boundaries from original bitmap. This color is used for filling extra space in bitmap ///  public static Bitmap RotateImage(Bitmap bmpSrc, double theta, Color? extendedBitmapBackground = null) { theta = Convert.ToSingle(theta * 180 / Math.PI); Matrix mRotate = new Matrix(); mRotate.Translate(bmpSrc.Width / -2, bmpSrc.Height / -2, MatrixOrder.Append); mRotate.RotateAt((float)theta, new Point(0, 0), MatrixOrder.Append); using (GraphicsPath gp = new GraphicsPath()) { // transform image points by rotation matrix gp.AddPolygon(new Point[] { new Point(0, 0), new Point(bmpSrc.Width, 0), new Point(0, bmpSrc.Height) }); gp.Transform(mRotate); PointF[] pts = gp.PathPoints; // create destination bitmap sized to contain rotated source image Rectangle bbox = BoundingBox(bmpSrc, mRotate); Bitmap bmpDest = new Bitmap(bbox.Width, bbox.Height); using (Graphics gDest = Graphics.FromImage(bmpDest)) { if (extendedBitmapBackground != null) { gDest.Clear(extendedBitmapBackground.Value); } // draw source into dest Matrix mDest = new Matrix(); mDest.Translate(bmpDest.Width / 2, bmpDest.Height / 2, MatrixOrder.Append); gDest.Transform = mDest; gDest.DrawImage(bmpSrc, pts); return bmpDest; } } } private static Rectangle BoundingBox(Image img, Matrix matrix) { GraphicsUnit gu = new GraphicsUnit(); Rectangle rImg = Rectangle.Round(img.GetBounds(ref gu)); // Transform the four points of the image, to get the resized bounding box. Point topLeft = new Point(rImg.Left, rImg.Top); Point topRight = new Point(rImg.Right, rImg.Top); Point bottomRight = new Point(rImg.Right, rImg.Bottom); Point bottomLeft = new Point(rImg.Left, rImg.Bottom); Point[] points = new Point[] { topLeft, topRight, bottomRight, bottomLeft }; GraphicsPath gp = new GraphicsPath(points, new byte[] { (byte)PathPointType.Start, (byte)PathPointType.Line, (byte)PathPointType.Line, (byte)PathPointType.Line }); gp.Transform(matrix); return Rectangle.Round(gp.GetBounds()); } 

Richard Cox hat eine gute Lösung für dieses https://stackoverflow.com/a/5200280/1171321, das ich in der Vergangenheit benutzt habe. Es ist auch erwähnenswert, dass die DPI 96 richtig funktionieren muss. Einige der Lösungen auf dieser Seite funktionieren überhaupt nicht.

Alte Frage, aber ich musste Herrn Fox’s Kommentar in der angenommenen Antwort ansprechen. Wenn Sie ein Bild drehen, wenn sich die Größe ändert, werden die Kanten des Bildes abgeschnitten. Eine Lösung besteht darin, das Original auf einem größeren Bild in der Mitte neu zu zeichnen, wobei die Abmessungen des größeren Bildes die Notwendigkeit kompensieren, die Kanten nicht zu beschneiden. Zum Beispiel wollte ich in der Lage sein, die Kacheln eines Spiels in einem normalen angular zu entcasting, aber sie in einem 45-Grad-angular für eine isometrische Ansicht neu zu zeichnen.

Hier sind Beispielbilder (gelbe Ränder sollen es hier leichter machen).

Das ursprüngliche Bild: Wasserfliese

Die zentrierte Kachel in einem größeren Bild: Bildbeschreibung hier eingeben

Das gedrehte Bild (wo Sie das größere Bild und nicht das Original drehen): Bildbeschreibung hier eingeben

Der Code (basierend teilweise auf dieser Antwort in einer anderen Frage ):

 private Bitmap RotateImage(Bitmap rotateMe, float angle) { //First, re-center the image in a larger image that has a margin/frame //to compensate for the rotated image's increased size var bmp = new Bitmap(rotateMe.Width + (rotateMe.Width / 2), rotateMe.Height + (rotateMe.Height / 2)); using (Graphics g = Graphics.FromImage(bmp)) g.DrawImageUnscaled(rotateMe, (rotateMe.Width / 4), (rotateMe.Height / 4), bmp.Width, bmp.Height); bmp.Save("moved.png"); rotateMe = bmp; //Now, actually rotate the image Bitmap rotatedImage = new Bitmap(rotateMe.Width, rotateMe.Height); using (Graphics g = Graphics.FromImage(rotatedImage)) { g.TranslateTransform(rotateMe.Width / 2, rotateMe.Height / 2); //set the rotation point as the center into the matrix g.RotateTransform(angle); //rotate g.TranslateTransform(-rotateMe.Width / 2, -rotateMe.Height / 2); //restore rotation point into the matrix g.DrawImage(rotateMe, new Point(0, 0)); //draw the image on the new bitmap } rotatedImage.Save("rotated.png"); return rotatedImage; } 

Dies funktioniert so lange, wie sich das Bild, das Sie drehen möchten, bereits in Ihrem Eigenschaftsressourcenordner befindet.

In Teilklasse:

 Bitmap bmp2; 

OnLoad:

  bmp2 = new Bitmap(Tycoon.Properties.Resources.save2); pictureBox6.SizeMode = PictureBoxSizeMode.StretchImage; pictureBox6.Image = bmp2; 

Knopf oder Onclick

 private void pictureBox6_Click(object sender, EventArgs e) { if (bmp2 != null) { bmp2.RotateFlip(RotateFlipType.Rotate90FlipNone); pictureBox6.Image = bmp2; } } 

Sie können dies leicht tun, indem Sie diese Methode aufrufen:

 public static Bitmap RotateImage(Image image, float angle) { if (image == null) throw new ArgumentNullException("image"); PointF offset = new PointF((float)image.Width / 2, (float)image.Height / 2); //create a new empty bitmap to hold rotated image Bitmap rotatedBmp = new Bitmap(image.Width, image.Height); rotatedBmp.SetResolution(image.HorizontalResolution, image.VerticalResolution); //make a graphics object from the empty bitmap Graphics g = Graphics.FromImage(rotatedBmp); //Put the rotation point in the center of the image g.TranslateTransform(offset.X, offset.Y); //rotate the image g.RotateTransform(angle); //move the image back g.TranslateTransform(-offset.X, -offset.Y); //draw passed in image onto graphics object g.DrawImage(image, new PointF(0, 0)); return rotatedBmp; } 

Vergessen Sie nicht, einen Verweis auf System.Drawing.dll in Ihrem Projekt hinzuzufügen

Beispiel für diesen Methodenaufruf:

 Image image = new Bitmap("waves.png"); Image newImage = RotateImage(image, 360); newImage.Save("newWaves.png");