EmguCV学习笔记 C# 5.2 仿射变换

本文主要是介绍EmguCV学习笔记 C# 5.2 仿射变换，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

 版权声明：本文为博主原创文章，转载请在显著位置标明本文出处以及作者网名，未经作者允许不得用于商业目的。

EmguCV是一个基于OpenCV的开源免费的跨平台计算机视觉库,它向C#和VB.NET开发者提供了OpenCV库的大部分功能。

教程VB.net版本请访问：EmguCV学习笔记 VB.Net 目录-CSDN博客

教程C#版本请访问：EmguCV学习笔记 C# 目录-CSDN博客

笔者的博客网址：https://blog.csdn.net/uruseibest

教程配套文件及相关说明以及如何获得pdf教程和代码，请移步：EmguCV学习笔记

学习VB.Net知识，请移步： vb.net 教程 目录_vb中如何用datagridview-CSDN博客

 学习C#知识，请移步：C# 教程 目录_c#教程目录-CSDN博客

5.2 仿射变换

仿射变换是一种保持直线在变换前后仍然保持直线的线性变换，可以用来对图像进行旋转、平移、缩放、错切等操作。通过仿射变换，可以对图像进行各种形式的几何变换，从而实现图像的校正、纠正畸变、图像拼接等操作。

仿射变换是通过三个点的变化来定位，读者可以想象把矩形左上、右上、左下，这三个顶点来做变化，剩下的右下顶点与左下、右上的边始终保持与其他两条边平行。

在使用Emgu.CV进行仿射变换时，需要注意选择合适的关键点以及目标图像的大小，以确保变换效果符合预期。此外，还可以使用其他函数和方法来进一步对变换后的图像进行处理和优化，如图像增强、边缘检测等。

5.2.1 warpAffine   

在Emgu.CV中，仿射变换可以通过CvInvoke的WarpAffine方法来实现。该方法接受源图像、变换矩阵（2x3的矩阵）和目标图像的大小作为参数，可以将源图像根据变换矩阵进行仿射变换，并将结果存储在目标图像中。

通常仿射变换的步骤如下：

1. 创建一个2×3的仿射变换矩阵，可以使用CvInvoke.GetAffineTransform方法（参看第5.2.2节）来创建，该方法接受源图像中的三个关键点和目标图像中的三个关键点作为参数，返回一个2×3的仿射变换矩阵。

2. 使用CvInvoke.WarpAffine方法进行仿射变换。该方法接受源图像、变换矩阵和目标图像的大小作为参数，可以将源图像根据变换矩阵进行仿射变换，并将结果存储在目标图像中。

WarpAffine方法的声明如下：

public static void WarpAffine(

           IInputArray src,

                    IOutputArray dst,

                    IInputArray mapMatrix,

                    Size dsize,

                    Inter interMethod = Inter.Linear,

                    Warp warpMethod = Warp.Default,

                    BorderType borderMode = BorderType.Constant,

           MCvScalar borderValue = default

)

主要参数说明：

1. mapMatrix：仿射变换矩阵。
2. dsize：输出图像的尺寸，需要考虑仿射变换后，图像超出原尺寸。
3. borderValue：填充颜色，表示在变换过程中，如果目标图像超出原始图像范围，用于填充的颜色。默认是黑色填充。

在WarpAffine函数的参数中，仿射变换矩阵mapMatrix用于定义图像的仿射变换操作。仿射变换矩阵是一个2x3的矩阵，其中包含了平移、旋转、缩放和剪切等变换的参数。

仿射变换矩阵的具体定义如下：

| a(0, 0)  a(0, 1)  a(0, 2) |

| a(1, 0)  a(1, 1)  a(1, 2) |

其中：

a(0, 0)和a(1, 1)表示图像的水平和垂直缩放系数，分别对应于x轴和y轴的缩放。当a(0, 0)和a(1, 1)的值为1时，表示不进行缩放。

a(0, 1)和a(1, 0)表示图像的剪切系数，分别对应于x轴和y轴的剪切。当a(0, 1)和a(1, 0)的值为0时，表示不进行剪切。

a(0, 2)和a(1, 2)表示图像的平移量，即图像在x轴和y轴上的平移距离。

通过修改仿射变换矩阵的参数，可以实现不同的图像变换效果。下面是一些常见的仿射变换操作：

1. 平移变换：

将图像向右平移dx个像素： [1.0, 0.0, dx, 0.0, 1.0, 0.0]

将图像向下平移dy个像素： [1.0, 0.0, 0.0, 0.0, 1.0, dy]

2. 旋转变换：

绕图像中心逆时针旋转theta弧度： [Math.Cos(theta), -Math.Sin(theta), 0.0, Math.Sin(theta), Math.Cos(theta), 0.0)]

这里是弧度，如果使用角度，请看下面的代码。

3. 缩放变换：

在x轴方向上缩放sx倍，y轴方向上缩放sy倍： [sx, 0.0, 0.0, 0.0, sy, 0.0]

4. 剪切变换：

在x轴方向上剪切tx个像素，y轴方向上剪切ty个像素：[1.0, tx, 0.0, ty, 1.0, 0.0]

【代码位置：frmChapter5】Button7_Click

        //WarpAffine仿射变换

        private void Button7_Click(object sender, EventArgs e)

        {

            Mat m = new Mat("C:\\learnEmgucv\\lena.jpg", ImreadModes.Color);

            CvInvoke.Imshow("src", m);

            Matrix<Double> ma1 = new Matrix<Double>(2, 3);

            ma1[0, 0] = 1.0F;

            ma1[0, 1] = -0.5F;

            ma1[0, 2] = 20.0F;

            ma1[1, 0] = 0.5F;

            ma1[1, 1] = 0.5F;

            ma1[1, 2] = 0F;

            Mat dst1 = new Mat();

            CvInvoke.WarpAffine(m, dst1, ma1, new Size(m.Width * 1, m.Height * 1), Inter.Linear, Warp.Default, BorderType.Constant, new MCvScalar(255, 0, 0));

            CvInvoke.Imshow("dst1", dst1);

            //顺时针方向旋转30度

            Single theta = 30.0F * (Single)Math.PI / 180;

            //仿射矩阵：

            Matrix<Double> ma2 = new Matrix<Double>(2, 3);

            ma2[0, 0] = Math.Cos(theta);

            ma2[0, 1] = -1 * Math.Sin(theta);

            ma2[0, 2] = 0F;

            ma2[1, 0] = Math.Sin(theta);

            ma2[1, 1] = Math.Cos(theta);

            ma2[1, 2] = 0F;

            Mat dst2 = new Mat();

            //仿射变换

            CvInvoke.WarpAffine(m, dst2, ma2, new Size(m.Width * 1, m.Height * 1));

            CvInvoke.Imshow("dst2", dst2);

        }

运行后如下图所示：

 

图5-7 仿射变换

5.2.2 GetAffineTransform    

在上一节的代码中使用的是自己填充的仿射变换矩阵，这个需要开发者手动计算矩阵的数据。而实际在EmguCV中，可以使用CvInvoke提供的GetAffineTransform方法来获取仿射变换矩阵。该方法只需要开发者提供三个点前后的变化即可，声明如下：

public static Mat GetAffineTransform(

           PointF[] src,

           PointF[] dest

)

参数说明：

1. src：源图像中三个的坐标，类型为PointF[]。
2. dest：目标图像中三个点的坐标，类型为PointF[]。

返回值：返回仿射变换矩阵，类型为Mat。

下面的代码，展示了如何使用 GetAffineTransform来获取仿射变换矩阵：

        '根据三点得到仿射变换矩阵

        PointF[] srcpoint=new PointF[3];

        srcpoint[0] = New PointF(0, 0);

        srcpoint[1] = New PointF(0, srcheight);

        srcpoint[2) = New PointF(srcwidth, 0);

        PointF[] dstpoint=new PointF[3];

        dstpoint[0] = New PointF(0, 0);

        dstpoint[1] = New PointF(srcwidth/2, srcheight/2);

        dstpoint[2] = New PointF(srcwidth/2, -srcheight/2);

        Mat rtm = new Mat();

    rtm = CvInvoke.GetAffineTransform(srcpoint, dstpoint);

上述代码中，srcpoint是源图像中的三个点，这里设置为了源图像的左上角、左下角和右上角。Dstpoint是目标图像的三个点，分别对应源图像中的三个点，与源图像三个点的对应关系：

源图像左上角位置不变。

源图像左下角移动到对应源图像中心点位置。

源图像右上角移动到对应源图像上方宽度一半、高度一半位置。

通过上述仿射变换得到的图像如下：

 

图5-8 仿射变换图像

上述代码中的点数组也可以更换为：

        PointF[] srcpoint=new PointF[3];

        srcpoint[0] = New PointF(0, 0);

        srcpoint[1] = New PointF(20, 0);

        srcpoint[2] = New PointF(0, 20);

        PointF[] dstpoint=new PointF[3];

        dstpoint[0] = New PointF(0, 0);

        dstpoint[1] = New PointF(10, -10);

    dstpoint[2] = New PointF(10, 10);

注意：上述替换只能是目标图像相对源图像左上角点（0，0）不变的情况，如果左上角点变换了，需要以实际为准。

【代码位置：frmChapter5】Button8_Click

        //仿射变换

        private void Button8_Click(object sender, EventArgs e)

        {

            Mat m = new Mat("C:\\learnEmgucv\\lena.jpg", Emgu.CV.CvEnum.ImreadModes.Color);

            ImageBox1.Image = m;

            //根据三点得到仿射变换矩阵

            PointF[] srcpoint1=new PointF[3];

            srcpoint1[0] = new PointF(0, 0);

            srcpoint1[1] = new PointF(0, 20);

            srcpoint1[2] = new PointF(20, 0);

            PointF[] dstpoint1 = new PointF[3];

            dstpoint1[0] = new PointF(0, 0);

            dstpoint1[1] = new PointF(10, -10);

            dstpoint1[2] = new PointF(10, 10);

            Mat rtm1 = new Mat();

            //获得仿射变换矩阵

            rtm1 = CvInvoke.GetAffineTransform(srcpoint1, dstpoint1);

            Mat dst1 = new Mat();

            CvInvoke.WarpAffine(m, dst1, rtm1, new Size(m.Width, m.Height));

            ImageBox2.Image = dst1;

            //根据三点得到仿射变换矩阵

            PointF[] srcpoint2 = new PointF[3];

            srcpoint2[0] = new PointF(0, 0);

            srcpoint2[1] = new PointF(m.Width, 0);

            srcpoint2[2] = new PointF(0, m.Height);

            PointF[] dstpoint2= new PointF[3];

            dstpoint2[0] = new PointF(m.Width / 2, m.Height / 2);

            dstpoint2[1] = new PointF(m.Width, m.Height);

            dstpoint2[2] = new PointF(0, m.Height);

            Mat rtm2 = new Mat();

            //获得仿射变换矩阵

            rtm2 = CvInvoke.GetAffineTransform(srcpoint2, dstpoint2);

            Mat dst2 = new Mat();

            CvInvoke.WarpAffine(m, dst2, rtm2, new Size(m.Width, m.Height));

            ImageBox3.Image = dst2;

        }

运行后如下图所示：

 

图5-9 仿射变换后的图像

5.2.3 GetRotationMatrix2D

在EmguCV中还可以使用CvInvoke的GetRotationMatrix2D方法来获取旋转后的仿射变换矩阵。该方法声明如下：

public static void GetRotationMatrix2D(

           PointF center,

                    double angle,

                    double scale,

           IOutputArray mapMatrix

)

参数说明：

1. center：旋转中心点坐标。
2. angle：旋转角度。
3. scale：缩放比例。
4. mapMatrix：输出的仿射变换矩阵。

【代码位置：frmChapter5】Button9_Click

       //使用GetRotationMatrix2D进行仿射变换

        private void Button9_Click(object sender, EventArgs e)

        {

            Mat m = new Mat("C:\\learnEmgucv\\lena.jpg", Emgu.CV.CvEnum.ImreadModes.Color);

            ImageBox1.Image = m;

            //得到仿射变换矩阵

            Mat rmm = new Mat();

            //图像中心点，30度，不缩放

            CvInvoke.GetRotationMatrix2D(new PointF(m.Width / 2, m.Height / 2), 30, 1, rmm);

            //仿射变换

            Mat dst = new Mat();

            CvInvoke.WarpAffine(m, dst, rmm, new Size(m.Width, m.Height));

            ImageBox2.Image = dst;

        }

运行后如下图所示：

 

图5-10 旋转后的图像

这篇关于EmguCV学习笔记 C# 5.2 仿射变换的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---