c#数字图像处理（十一）图像旋转

如果平面上的点绕原点逆时针旋转θº，则其坐标变换公式为：

x'=xcosθ+ysinθ   y=-xsinθ+ycosθ

其中，(x, y)为原图坐标，(x’, y’)为旋转后的坐标。它的逆变换公式为：

x=x'cosθ-y'sinθ   y=x'sinθ+y'cosθ

矩阵形式为：

和缩放类似，旋转后的图像的像素点也需要经过坐标转换为原始图像上的坐标来确定像素值，同样也可能找不到对应点，因此旋转也用到插值法。在此选用性能较好的双线性插值法。为提高速度，在处理旋转90º、-90º、±180º时使用了镜像来处理。

        /// <summary>
        /// 图像旋转
        /// </summary>
        /// <param name="srcBmp">原始图像</param>
        /// <param name="degree">旋转角度</param>
        /// <param name="dstBmp">目标图像</param>
        /// <returns>处理成功 true 失败 false</returns>
        public static bool Rotation(Bitmap srcBmp, double degree, out Bitmap dstBmp)
        {
            if (srcBmp == null)
            {
                dstBmp = null;
                return false;
            }
            dstBmp = null;
            BitmapData srcBmpData = null;
            BitmapData dstBmpData = null;
            switch ((int)degree)
            {
                case :
                    dstBmp = new Bitmap(srcBmp);
                    break;
                case -:
                    dstBmp = new Bitmap(srcBmp.Height, srcBmp.Width);
                    srcBmpData = srcBmp.LockBits(new Rectangle(, , srcBmp.Width, srcBmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
                    dstBmpData = dstBmp.LockBits(new Rectangle(, , dstBmp.Width, dstBmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
                    unsafe
                    {
                        byte* ptrSrc = (byte*)srcBmpData.Scan0;
                        byte* ptrDst = (byte*)dstBmpData.Scan0;
                        for (int i = ; i < srcBmp.Height; i++)
                        {
                            for (int j = ; j < srcBmp.Width; j++)
                            {
                                ptrDst[j * dstBmpData.Stride + (dstBmp.Height - i - ) * ] = ptrSrc[i * srcBmpData.Stride + j * ];
                                ptrDst[j * dstBmpData.Stride + (dstBmp.Height - i - ) *  + ] = ptrSrc[i * srcBmpData.Stride + j *  + ];
                                ptrDst[j * dstBmpData.Stride + (dstBmp.Height - i - ) *  + ] = ptrSrc[i * srcBmpData.Stride + j *  + ];
                            }
                        }
                    }
                    srcBmp.UnlockBits(srcBmpData);
                    dstBmp.UnlockBits(dstBmpData);
                    break;
                case :
                    dstBmp = new Bitmap(srcBmp.Height, srcBmp.Width);
                    srcBmpData = srcBmp.LockBits(new Rectangle(, , srcBmp.Width, srcBmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
                    dstBmpData = dstBmp.LockBits(new Rectangle(, , dstBmp.Width, dstBmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
                    unsafe
                    {
                        byte* ptrSrc = (byte*)srcBmpData.Scan0;
                        byte* ptrDst = (byte*)dstBmpData.Scan0;
                        for (int i = ; i < srcBmp.Height; i++)
                        {
                            for (int j = ; j < srcBmp.Width; j++)
                            {
                                ptrDst[(srcBmp.Width - j - ) * dstBmpData.Stride + i * ] = ptrSrc[i * srcBmpData.Stride + j * ];
                                ptrDst[(srcBmp.Width - j - ) * dstBmpData.Stride + i *  + ] = ptrSrc[i * srcBmpData.Stride + j *  + ];
                                ptrDst[(srcBmp.Width - j - ) * dstBmpData.Stride + i *  + ] = ptrSrc[i * srcBmpData.Stride + j *  + ];
                            }
                        }
                    }
                    srcBmp.UnlockBits(srcBmpData);
                    dstBmp.UnlockBits(dstBmpData);
                    break;
                case :
                case -:
                    dstBmp = new Bitmap(srcBmp.Width, srcBmp.Height);
                    srcBmpData = srcBmp.LockBits(new Rectangle(, , srcBmp.Width, srcBmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
                    dstBmpData = dstBmp.LockBits(new Rectangle(, , dstBmp.Width, dstBmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
                    unsafe
                    {
                        byte* ptrSrc = (byte*)srcBmpData.Scan0;
                        byte* ptrDst = (byte*)dstBmpData.Scan0;
                        for (int i = ; i < srcBmp.Height; i++)
                        {
                            for (int j = ; j < srcBmp.Width; j++)
                            {
                                ptrDst[(srcBmp.Width - i - ) * dstBmpData.Stride + (dstBmp.Height - j - ) * ] = ptrSrc[i * srcBmpData.Stride + j * ];
                                ptrDst[(srcBmp.Width - i - ) * dstBmpData.Stride + (dstBmp.Height - j - ) *  + ] = ptrSrc[i * srcBmpData.Stride + j *  + ];
                                ptrDst[(srcBmp.Width - i - ) * dstBmpData.Stride + (dstBmp.Height - j - ) *  + ] = ptrSrc[i * srcBmpData.Stride + j *  + ];
                            }
                        }
                    }
                    srcBmp.UnlockBits(srcBmpData);
                    dstBmp.UnlockBits(dstBmpData);
                    break;
                default://任意角度
                    double radian = degree * Math.PI / 180.0;//将角度转换为弧度
                                                             //计算正弦和余弦
                    double sin = Math.Sin(radian);
                    double cos = Math.Cos(radian);
                    //计算旋转后的图像大小
                    int widthDst = (int)(srcBmp.Height * Math.Abs(sin) + srcBmp.Width * Math.Abs(cos));
                    int heightDst = (int)(srcBmp.Width * Math.Abs(sin) + srcBmp.Height * Math.Abs(cos));

                    dstBmp = new Bitmap(widthDst, heightDst);
                    //确定旋转点
                    int dx = (int)(srcBmp.Width /  * ( - cos) + srcBmp.Height /  * sin);
                    int dy = (int)(srcBmp.Width /  * ( - sin) + srcBmp.Height /  * ( - cos));

                    int insertBeginX = srcBmp.Width /  - widthDst / ;
                    int insertBeginY = srcBmp.Height /  - heightDst / ;

                    //插值公式所需参数
                    double ku = insertBeginX * cos - insertBeginY * sin + dx;
                    double kv = insertBeginX * sin + insertBeginY * cos + dy;
                    double cu1 = cos, cu2 = sin;
                    double cv1 = sin, cv2 = cos;

                    double fu, fv, a, b, F1, F2;
                    int Iu, Iv;
                    srcBmpData = srcBmp.LockBits(new Rectangle(, , srcBmp.Width, srcBmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
                    dstBmpData = dstBmp.LockBits(new Rectangle(, , dstBmp.Width, dstBmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

                    unsafe
                    {
                        byte* ptrSrc = (byte*)srcBmpData.Scan0;
                        byte* ptrDst = (byte*)dstBmpData.Scan0;
                        for (int i = ; i < heightDst; i++)
                        {
                            for (int j = ; j < widthDst; j++)
                            {
                                fu = j * cu1 - i * cu2 + ku;
                                fv = j * cv1 + i * cv2 + kv;
                                if ((fv < ) || (fv > srcBmp.Height - ) || (fu < ) || (fu > srcBmp.Width - ))
                                {

                                    ptrDst[i * dstBmpData.Stride + j * ] = ;
                                    ptrDst[i * dstBmpData.Stride + j *  + ] = ;
                                    ptrDst[i * dstBmpData.Stride + j *  + ] = ;
                                }
                                else
                                {//双线性插值
                                    Iu = (int)fu;
                                    Iv = (int)fv;
                                    a = fu - Iu;
                                    b = fv - Iv;
                                    for (int k = ; k < ; k++)
                                    {
                                        F1 = ( - b) * *(ptrSrc + Iv * srcBmpData.Stride + Iu *  + k) + b * *(ptrSrc + (Iv + ) * srcBmpData.Stride + Iu *  + k);
                                        F2 = ( - b) * *(ptrSrc + Iv * srcBmpData.Stride + (Iu + ) *  + k) + b * *(ptrSrc + (Iv + ) * srcBmpData.Stride + (Iu + ) *  + k);
                                        *(ptrDst + i * dstBmpData.Stride + j *  + k) = (byte)(( - a) * F1 + a * F2);
                                    }
                                }
                            }
                        }
                    }
                    srcBmp.UnlockBits(srcBmpData);
                    dstBmp.UnlockBits(dstBmpData);
                    break;
            }
            return true;
        }