using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

using System.Collections;

using System.Diagnostics;

using System.Drawing.Imaging;

//窗体调用

private Bitmap RotateImage(Bitmap bmp, double angle)

        {

            Graphics g = null;

            Bitmap tmp = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format32bppRgb);

            tmp.SetResolution(bmp.HorizontalResolution, bmp.VerticalResolution);

            g = Graphics.FromImage(tmp);

            try

            {

                g.FillRectangle(Brushes.White, , , bmp.Width, bmp.Height);

                g.RotateTransform((float)angle);

                g.DrawImage(bmp, , );

            }

            finally

            {

                g.Dispose();

            }

            return tmp;

        }

        private void button1_Click(object sender, EventArgs e)

        {

           string fnIn = "f:\\test\\image0097_4.tif";

            string fnOut = "f:\\test\\output.tif";

            Bitmap bmpIn = new Bitmap(fnIn);

            gmseDeskew sk = new gmseDeskew(bmpIn);

            double skewangle = sk.GetSkewAngle();

            Bitmap bmpOut = RotateImage(bmpIn, -skewangle);

            bmpOut.Save(fnOut, ImageFormat.Tiff);//此处简单保存，可采用压缩方式保存

                   }

#region 算法处理类

public class gmseDeskew

    {

        public class HougLine

        {

            // Count of points in the line.

            public int Count;

            // Index in Matrix.

            public int Index;

            // The line is represented as all x,y that solve y*cos(alpha)-x*sin(alpha)=d

            public double Alpha;

            public double d;

        }

        Bitmap cBmp;

        double cAlphaStart = -;

        double cAlphaStep = 0.2;

        int cSteps =  * ;

        double[] cSinA;

        double[] cCosA;

        double cDMin;

        double cDStep = ;

        int cDCount;

        // Count of points that fit in a line.

        int[] cHMatrix;

        public double GetSkewAngle()

        {

            gmseDeskew.HougLine[] hl = null;

            int i = ;

            double sum = ;

            int count = ;

            // Hough Transformation 

           Calc();

            // Top 20 of the detected lines in the image.

            hl = GetTop();

            // Average angle of the lines

            for (i = ; i <= ; i++)

            {

                sum += hl[i].Alpha;

                count += ;

            }

            return sum / count;

        }

        private HougLine[] GetTop(int Count)

        {

            HougLine[] hl = null;

            int i = ;

            int j = ;

            HougLine tmp = null;

            int AlphaIndex = ;

            int dIndex = ;

            hl = new HougLine[Count + ];

            for (i = ; i <= Count - ; i++)

            {

                hl[i] = new HougLine();

            }

            for (i = ; i <= cHMatrix.Length - ; i++)

            {

                if (cHMatrix[i] > hl[Count - ].Count)

                {

                    hl[Count - ].Count = cHMatrix[i];

                    hl[Count - ].Index = i;

                    j = Count - ;

                    while (j >  && hl[j].Count > hl[j - ].Count)

                    {

                        tmp = hl[j];

                        hl[j] = hl[j - ];

                        hl[j - ] = tmp; j -= ;

                    }

                }

            }

            for (i = ; i <= Count - ; i++)

            {

                dIndex = hl[i].Index / cSteps;

                AlphaIndex = hl[i].Index - dIndex * cSteps;

                hl[i].Alpha = GetAlpha(AlphaIndex);

                hl[i].d = dIndex + cDMin;

            }

            return hl;

        }

        public gmseDeskew(Bitmap bmp)

        {

            cBmp = bmp;

        }

        private void Calc()

        {

            int x = ;

            int y = ;

            int hMin = cBmp.Height / ;

            int hMax = cBmp.Height *  / ;

            Init();

            for (y = hMin; y <= hMax; y++)

            {

                for (x = ; x <= cBmp.Width - ; x++)

                {    // Only lower edges are considered.

                    if (IsBlack(x, y))

                    {

                        if (!IsBlack(x, y + ))

                        {

                            Calc(x, y);

                        }

                    }

                }

            }

        }

        private void Calc(int x, int y)

        {

            int alpha = ;

            double d = ;

            int dIndex = ;

            int Index = ;

            for (alpha = ; alpha <= cSteps - ; alpha++)

            {

                d = y * cCosA[alpha] - x * cSinA[alpha];

                dIndex = (int)CalcDIndex(d);

                Index = dIndex * cSteps + alpha;

                try

                {

                    cHMatrix[Index] += ;

                }

                catch (Exception ex)

                {

                    Debug.WriteLine(ex.ToString());

                }

            }

        }

        private double CalcDIndex(double d)

        {

            return Convert.ToInt32(d - cDMin);

        }

        private bool IsBlack(int x, int y)

        {

            Color c = default(Color);

            double luminance = ;

            c = cBmp.GetPixel(x, y);

            luminance = (c.R * 0.299) + (c.G * 0.587) + (c.B * 0.114);

            return luminance < ;

        }

        private void Init()

        {

            int i = ;

            double angle = ;

            // Precalculation of sin and cos.

            cSinA = new double[cSteps];

            cCosA = new double[cSteps];

            for (i = ; i <= cSteps - ; i++)

            {

                angle = GetAlpha(i) * Math.PI / 180.0;

                cSinA[i] = Math.Sin(angle);

                cCosA[i] = Math.Cos(angle);

            }  // Range of d:

            cDMin = -cBmp.Width;

            cDCount = (int)( * (cBmp.Width + cBmp.Height) / cDStep);

            cHMatrix = new int[cDCount * cSteps + ];

        }

        public double GetAlpha(int Index)

        {

            return cAlphaStart + Index * cAlphaStep;

        }

    }

#endregion