Image Rotation in .NET

g.CompositingQuality= CompositingQuality.HighSpeed;
g.SmoothingMode = SmoothingMode.HighSpeed;

public static Bitmap RotateImage(Image image, double angle, bool highDetail)
        {
            if (image == null)
                throw new ArgumentNullException("image");
 
            const double pi2 = Math.PI / 2.0D;
 
            // Why can't C# allow these to be const, or at least readonly
            // *sigh*  I'm starting to talk like Christian Graus :omg:
            double oldWidth = (double)image.Width;
            double oldHeight = (double)image.Height;
 
            // Convert degrees to radians
            double theta = angle * Math.PI / 180.0D;
            double locked_theta = theta;
 
            // Ensure theta is now [0, 2pi)
            while (locked_theta < 0.0D)
                locked_theta += 2.0D * Math.PI;
 
            double newWidth, newHeight;
            int nWidth, nHeight; // The newWidth/newHeight expressed as ints

        #region Explaination of the calculations
            /*
			 * The trig involved in calculating the new width and height
			 * is fairly simple; the hard part was remembering that when 
			 * PI/2 <= theta <= PI and 3PI/2 <= theta < 2PI the width and 
			 * height are switched.
			 * 
			 * When you rotate a rectangle, r, the bounding box surrounding r
			 * contains for right-triangles of empty space.  Each of the 
			 * triangles hypotenuse's are a known length, either the width or
			 * the height of r.  Because we know the length of the hypotenuse
			 * and we have a known angle of rotation, we can use the trig
			 * function identities to find the length of the other two sides.
			 * 
			 * sine = opposite/hypotenuse
			 * cosine = adjacent/hypotenuse
			 * 
			 * solving for the unknown we get
			 * 
			 * opposite = sine * hypotenuse
			 * adjacent = cosine * hypotenuse
			 * 
			 * Another interesting point about these triangles is that there
			 * are only two different triangles. The proof for which is easy
			 * to see, but its been too long since I've written a proof that
			 * I can't explain it well enough to want to publish it.  
			 * 
			 * Just trust me when I say the triangles formed by the lengths 
			 * width are always the same (for a given theta) and the same 
			 * goes for the height of r.
			 * 
			 * Rather than associate the opposite/adjacent sides with the
			 * width and height of the original bitmap, I'll associate them
			 * based on their position.
			 * 
			 * adjacent/oppositeTop will refer to the triangles making up the 
			 * upper right and lower left corners
			 * 
			 * adjacent/oppositeBottom will refer to the triangles making up 
			 * the upper left and lower right corners
			 * 
			 * The names are based on the right side corners, because thats 
			 * where I did my work on paper (the right side).
			 * 
			 * Now if you draw this out, you will see that the width of the 
			 * bounding box is calculated by adding together adjacentTop and 
			 * oppositeBottom while the height is calculate by adding 
			 * together adjacentBottom and oppositeTop.
			 */
            #endregion
 
            double adjacentTop, oppositeTop;
            double adjacentBottom, oppositeBottom;
 
            // We need to calculate the sides of the triangles based
            // on how much rotation is being done to the bitmap.
            //   Refer to the first paragraph in the explaination above for 
            //   reasons why.
            if ((locked_theta >= 0.0D && locked_theta < pi2) ||
                (locked_theta >= Math.PI && locked_theta < (Math.PI + pi2)))
            {
                adjacentTop = Math.Abs(Math.Cos(locked_theta)) * oldWidth;
                oppositeTop = Math.Abs(Math.Sin(locked_theta)) * oldWidth;
 
                adjacentBottom = Math.Abs(Math.Cos(locked_theta)) * oldHeight;
                oppositeBottom = Math.Abs(Math.Sin(locked_theta)) * oldHeight;
            }
            else
            {
                adjacentTop = Math.Abs(Math.Sin(locked_theta)) * oldHeight;
                oppositeTop = Math.Abs(Math.Cos(locked_theta)) * oldHeight;
 
                adjacentBottom = Math.Abs(Math.Sin(locked_theta)) * oldWidth;
                oppositeBottom = Math.Abs(Math.Cos(locked_theta)) * oldWidth;
            }
 
            newWidth = adjacentTop + oppositeBottom;
            newHeight = adjacentBottom + oppositeTop;
 
            nWidth = (int)newWidth;
            nHeight = (int)newHeight;
 
            Bitmap rotatedBmp = new Bitmap(nWidth, nHeight);
 
            using (Graphics g = Graphics.FromImage(rotatedBmp))
            {
                g.PixelOffsetMode = PixelOffsetMode.HighQuality;
                if (highDetail)
                {
                    g.SmoothingMode = SmoothingMode.HighQuality;
                    g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                }
 
                else
                {
                    g.SmoothingMode = SmoothingMode.None;
                    g.InterpolationMode = InterpolationMode.Low;
                }
 
                // This array will be used to pass in the three points that 
                // make up the rotated image
                PointF[] points;
 
                /*
                 * The values of opposite/adjacentTop/Bottom are referring to 
                 * fixed locations instead of in relation to the
                 * rotating image so I need to change which values are used
                 * based on the how much the image is rotating.
                 * 
                 * For each point, one of the coordinates will always be 0, 
                 * nWidth, or nHeight.  This because the Bitmap we are drawing on
                 * is the bounding box for the rotated bitmap.  If both of the 
                 * corrdinates for any of the given points wasn't in the set above
                 * then the bitmap we are drawing on WOULDN'T be the bounding box
                 * as required.
                 */
                if (locked_theta >= 0.0D && locked_theta < pi2)
                {
                    points = new PointF[] { 
											 new PointF( (float)oppositeBottom, 0.0F ), 
											 new PointF( (float)newWidth, (float)oppositeTop ),
											 new PointF( 0.0F, (float) adjacentBottom )
										 };
 
                }
                else if (locked_theta >= pi2 && locked_theta < Math.PI)
                {
                    points = new PointF[] { 
											 new PointF( (float)newWidth, (float) oppositeTop ),
											 new PointF( (float) adjacentTop, (float)newHeight ),
											 new PointF( (float) oppositeBottom, 0.0F )						 
										 };
                }
                else if (locked_theta >= Math.PI && locked_theta < (Math.PI + pi2))
                {
                    points = new PointF[] { 
											 new PointF( (float) adjacentTop, (float)newHeight ), 
											 new PointF( 0.0F, (float) adjacentBottom ),
											 new PointF( (float)newWidth, (float)oppositeTop )
										 };
                }
                else
                {
                    points = new PointF[] { 
											 new PointF( 0.0F, (float) adjacentBottom ), 
											 new PointF( (float) oppositeBottom, 0.0F ),
											 new PointF( (float) adjacentTop, (float)newHeight )		
										 };
                }
                g.DrawImage(image, points);
            }
            return rotatedBmp;
        }

public static Bitmap RotateImage2(Bitmap bmp, float angle)
{
     Bitmap retbmp = null;
 
     //Get the current rectangle points
     Point[] pts = new Point[]
     { 
          new Point(0, 0),
          new Point(bmp.Width, 0),
          new Point(bmp.Width, bmp.Height),
          new Point(0, bmp.Height)						 
     }; 
 
     // put the center point at (0,0) for the rotation
     for (int i = 0; i < 4; i++)
     {
          pts[i].X -= bmp.Width / 2;
          pts[i].Y -= bmp.Height / 2;
     }
 
     //rotate the Rectangle
     Matrix m = new Matrix();
     m.Rotate(angle);
     m.TransformPoints(pts);
     m.Dispose();
 
     //Locate the new rectangle
     int maxX = int.MinValue;
     int maxY = int.MinValue;
     int minX = int.MaxValue;
     int minY = int.MaxValue;
     for (int i = 0; i < 4; i++)
     {
          if (maxX < pts[i].X) maxX = pts[i].X;
          if (maxY < pts[i].Y) maxY = pts[i].Y;
 
          if (minX > pts[i].X) minX = pts[i].X;
          if (minY > pts[i].Y) minY = pts[i].Y;
     }
 
     //reset the points to a 0,0 base
     for (int i = 0; i < 4; i++)
     {
          pts[i].X -= minX;
          pts[i].Y -= minY;
     }
 
     //Create the new bitmap
     retbmp = new Bitmap(maxX - minX, maxY - minY, PixelFormat.Format32bppArgb);
  
     //Rotate the image onto the new Bitmap
     Graphics g = Graphics.FromImage(retbmp);
     Point[] finalPts = new Point[] { pts[0], pts[1], pts[3] };
     g.DrawImage(bmp, finalPts);
     g.Dispose();
            
 
     return retbmp;
}