图像几何运算 平移，镜像，缩放

最新推荐文章于 2022-01-18 23:24:29 发布
最新推荐文章于 2022-01-18 23:24:29 发布
阅读量1.4k 收藏
点赞数
分类专栏： Emgu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hackerjoy/article/details/7933142
版权

图像的平移

  private void translationBtn_Click(object sender, EventArgs e)
        {
            if (curBitmap != null)
            {
                //实例化translation窗口体
                translation traForm = new translation();

                if (traForm.ShowDialog() == DialogResult.OK)
                {
                    Rectangle rect = new Rectangle(0, 0, curBitmap.Width, curBitmap.Height);
                    System.Drawing.Imaging.BitmapData bmpData = curBitmap.LockBits(rect,
                        System.Drawing.Imaging.ImageLockMode.ReadWrite,
                        curBitmap.PixelFormat);
                    IntPtr ptr = bmpData.Scan0;
                    int bytes = bmpData.Stride * curBitmap.Height;//图像的跨度curBitmap.Width并不一定是其实际像素宽度
                    byte[] grayValues = new byte[bytes];
                    System.Runtime.InteropServices.Marshal.Copy(ptr, grayValues, 0, bytes);

                    //得到两个方向的图像平移量
                    int x = Convert.ToInt32(traForm.GetXOffset);
                    int y = Convert.ToInt32(traForm.GetYOffset);


                    byte[] tempArray = new byte[bytes];
                    //临时数组初始化为白色像素

                    for (int i = 0; i < bytes; i++)
                    {
                        tempArray[i] = 255;
                    }

                    //平移运算
                    for (int i = 0; i < curBitmap.Height; i++)
                    {
                        //保证纵向平移不出界
                        if ( (i + y) < curBitmap.Height && (i + y) > 0 ) 
                        {
                            for (int j = 0; j < bmpData.Stride; j++)
                            {
                                //保证横向不出界
                                if ((j + x) < bmpData.Stride && (j + x) > 0)
                                {
                                    //应用公式
                                    tempArray[(j + x) + (i + y) * bmpData.Stride] =
                                        grayValues[j + i * bmpData.Stride];
                                }
                            }
                        }

                    }
                    //数组复制，返回平移后的图像
                    grayValues = (byte[])tempArray.Clone();

                    System.Runtime.InteropServices.Marshal.Copy(grayValues, 0, ptr, bytes);
                    curBitmap.UnlockBits(bmpData);
                }

                Invalidate();
            }
        }

//图像镜像变换

 private void mirrorBtn_Click(object sender, EventArgs e)
        {
            if (curBitmap != null)
            {
                //实例化mirror窗口体
                Mirror mirForm = new Mirror();

                if (mirForm.ShowDialog() == DialogResult.OK)
                {
                    Rectangle rect = new Rectangle(0, 0, curBitmap.Width, curBitmap.Height);
                    System.Drawing.Imaging.BitmapData bmpData = curBitmap.LockBits(rect,
                        System.Drawing.Imaging.ImageLockMode.ReadWrite,
                        curBitmap.PixelFormat);

                    IntPtr ptr = bmpData.Scan0;
                    int bytes = bmpData.Stride * bmpData.Height;
                    byte[] grayValues = new byte[bytes];
                    System.Runtime.InteropServices.Marshal.Copy(ptr, grayValues, 0, bytes);

                    //水平中轴
                    int halfWidth = bmpData.Stride / 2;
                    //垂直中轴
                    int halfHeight = curBitmap.Height / 2;
                    byte temp;

                    if (mirForm.GetMirror)
                    {
                        //水平镜像处理
                        for (int i = 0; i < curBitmap.Height; i++)
                        {
                            for (int j = 0; j < halfWidth; j++)
                            {
                                //以水平中轴为对称轴， 两边的像素值互换
                                temp = grayValues[i * bmpData.Stride + j];
                                grayValues[i * bmpData.Stride + j] =
                                    grayValues[(i + 1) * bmpData.Stride - j - 1];
                                grayValues[(i + 1) * bmpData.Stride - 1 - j] = temp;
                            }

                        }
                    }
                    else
                    {
                        //垂直镜像处理
                        for (int i = 0; i < bmpData.Stride; i++)
                        {
                            for (int j = 0; j < halfHeight; j++)
                            {
                                //以垂直中轴为对称轴， 两边的像素值互换
                                temp = grayValues[j * bmpData.Stride + i];
                                grayValues[j * bmpData.Stride + i] =
                                    grayValues[(curBitmap.Height - j - 1) * bmpData.Stride + i];
                                grayValues[(curBitmap.Height - j - 1) * bmpData.Stride + i] =
                                    temp;

                            }

                        }
                    }
                    System.Runtime.InteropServices.Marshal.Copy(grayValues, 0, ptr, bytes);
                    curBitmap.UnlockBits(bmpData);
                }

                Invalidate();
            }
        }

//图像缩放

private void zoomBtn_Click(object sender, EventArgs e)
        {
            if (curBitmap != null)
            {
                //实例化zoom窗口
                zoom zoomForm = new zoom();

                if (zoomForm.ShowDialog() == DialogResult.OK)
                {
                    Rectangle rect = new Rectangle(0, 0, curBitmap.Width, curBitmap.Height);
                    System.Drawing.Imaging.BitmapData bmpdata = curBitmap.LockBits(rect,
                        System.Drawing.Imaging.ImageLockMode.ReadWrite,
                        curBitmap.PixelFormat);
                    IntPtr ptr = bmpdata.Scan0;
                    int bytes = bmpdata.Stride * curBitmap.Height;
                    byte[] grayValues = new byte[bytes];
                    System.Runtime.InteropServices.Marshal.Copy(ptr, grayValues, 0, bytes);

                    //得到横纵缩放量
                    double x = Convert.ToDouble(zoomForm.GetXZoom);
                    double y = Convert.ToDouble(zoomForm.GetYZoom);

                    //图像的几何中心
                    int halfWidth = (int)Convert.ToDouble(bmpdata.Stride / 2);
                    int halfHeight = (int)Convert.ToDouble(curBitmap.Height / 2);

                    int xz = 0;
                    int yz = 0;
                    int tempWidth = 0;
                    int tempHeight = 0;
                    byte[] tempArray = new byte[bytes];

                    if (zoomForm.GetNearOrBil == true)
                    {
                        //最近邻插值法
                        for (int i = 0; i < curBitmap.Height; i++)
                        {
                            for (int j = 0; j < bmpdata.Stride; j++)
                            {
                                //以图像的几何中心为坐标原点进行坐标变化
                                //按逆向映射法得到输入图像坐标
                                tempHeight = i - halfHeight;
                                tempWidth = j - halfWidth;

                                //在不同象限里进行四舍五入处理,得到缩放后像素点到中心点的距离
                                if (tempWidth > 0)
                                {
                                    xz = (int)(tempWidth / x + 0.5);
                                }
                                else
                                {
                                    xz = (int)(tempWidth / x - 0.5);
                                }

                                if (tempHeight > 0)
                                {
                                    yz = (int)(tempHeight / y + 0.5);
                                }
                                else
                                {
                                    yz = (int)(tempHeight / y - 0.5);
                                }

                                //坐标变换，得到缩放后像素的位置
                                tempWidth = xz + halfWidth;
                                tempHeight = yz + halfHeight;
                                //得到输出图像像素值
                                if (tempWidth < 0 || tempWidth >= bmpdata.Stride ||
                                    tempHeight < 0 || tempHeight >= curBitmap.Height)
                                {
                                    //缩放后留下的空白部分用白色像素代替
                                    tempArray[i * bmpdata.Stride + j] = 255;
                                }
                                else
                                {
                                    tempArray[i * bmpdata.Stride + j] =
                                        grayValues[tempHeight * bmpdata.Stride + tempWidth];
                                }
                            }
                        }
                    }
                    else
                    {
                        //双线性插值法
                        double tempX, tempY, p, q;
                        for (int i = 0; i < curBitmap.Height; i++)
                        {
                            for (int j = 0; j < bmpdata.Stride; j++)
                            {
                                //以图像的几何中心为坐标原点进行坐标变化
                                //按逆向映射法的到输入图像的坐标
                                tempHeight = i - halfHeight;
                                tempWidth = j - halfWidth;
                                tempX = tempWidth / x;
                                tempY = tempHeight / y;

                                //在不同象限进行取整处理
                                if (tempWidth > 0)
                                {
                                    xz = (int)tempX;
                                }
                                else
                                {
                                    xz = (int)(tempX - 1);
                                }
                                if (tempHeight > 0)
                                {
                                    yz = (int)tempY;
                                }
                                else
                                {
                                    yz = (int)(tempY - 1);
                                }

                                //得到公式中的变量p和q
                                p = tempX - xz;
                                q = tempY - yz;

                                //坐标变换
                                tempWidth = xz + halfWidth;
                                tempHeight = yz + halfHeight;

                                if (tempWidth < 0 || (tempWidth + 1) >= bmpdata.Stride ||
                                    tempHeight < 0 || (tempHeight + 1) >= curBitmap.Height)
                                {
                                    //缩放后留下的空白部分用白色像素代替
                                    tempArray[i * bmpdata.Stride + j] = 255;
                                }
                                else
                                {
                                    //应用公式得到双线性插值
                                    tempArray[i * bmpdata.Stride + j] =
                                        (byte)(
                                                (1.0 - q) * (
                                                              (1.0 - p) * grayValues[tempHeight * bmpdata.Stride + tempWidth]
                                                               +
                                                               p * grayValues[tempHeight * bmpdata.Stride + tempWidth + 1]
                                                             )
                                                  +
                                                 q *
                                                 (
                                                   (1.0 - q) * grayValues[(tempHeight + 1) * bmpdata.Stride + tempWidth]
                                                   +
                                                   p * grayValues[(tempHeight + 1) * bmpdata.Stride + 1 + tempWidth]
                                                 )
                                             );
                                }
                            }
                        }

                    }

                    grayValues = (byte[])tempArray.Clone();

                    System.Runtime.InteropServices.Marshal.Copy(grayValues, 0, ptr, bytes);
                    curBitmap.UnlockBits(bmpdata);
                   
                }

                Invalidate();
            }

 

hackerjoy
关注
专栏目录
[Python从零到壹] 三十八.图像处理基础篇之图像几何变换（平移缩放旋转）
杨秀璋的专栏
01-27 1万+
欢迎大家来到“Python从零到壹”，在这里我将分享约200篇Python系列文章，带大家一起去学习和玩耍。上一篇文章介绍了图像融合处理和ROI区域绘制，同时补充图像属性、通道和类型转换。这篇文章将详细讲解图像几何变换，包括图像平移、图像缩放和图像旋转。希望文章对您有所帮助，如果有不足之处，还请海涵。
图像平移(translation)运算和镜像(mirror)运算
FrozenShore
12-02 2039
还是以24位BMP图像为例，图像的平移和镜像运算都较为简单，只需要注意几点： 1、BMP图像像素宽度必须被4整除，因此如果平移后的像素宽度也必须对齐 2、BMP图像是倒着存放的，在平移的时候要得想明白坐标系朝向 顺便说句，之前几篇blog里面的代码我都要求输入图像input.bmp的像素宽度必须能被4整除，然后我觉得这么偷懒也不是办法 ＝ ＝。所以还是加了一些判定来解决这个问题。所以
数字图像的几何运算
GuoXuan_CHN的博客
04-22 951
数字图像的几何运算实验任务 图像的平移 图像的旋转 图像的缩放 源代码f = imread('./test.TIF'); ...imshow(f);...图像的缩放 f_15 = imresize(f,1.5,'nearest'); f_15 = imresize(f,1.5,'bilinear'); f_15 = imresize(f,1.5,'bicubic');f_5 = imresize(
MFC 图像处理之几何运算 图像平移旋转缩放镜像(源码)
06-04
该资源主要参考我的博客【数字图像处理】六.MFC空间几何变换之图像平移、镜像、旋转、缩放详解，博客地址http://blog.csdn.net/eastmount/article/details/46345299 主要讲述基于VC++6.0 MFC图像处理的应用知识，要通过MFC单文档视图实现显示BMP图片空间几何变换，包括图像平移、图形旋转、图像反转倒置镜像和图像缩放的知识，并结合前一篇论文灰度直方图进行展示 。其中代码中含有详细注释。免费资源，希望能结合原文学习，也期望对你有所帮助，尤其是初学者！By:Eastmount BUG修改见原文
图像运算平移，旋转，切变换
jialeheyeshu的博客
10-20 548
p=imread('lv.jpg'); %水平移动 figure; s=maketform('affine',[1 0 50;0 1 50;0 0 1]'); %构建maketform结构体 g=imtransform(p,s,'XData',[1 size(p,2)],'YData',[1 size(p,1)],'FillValue',255); %xdata显示范围，使用255色填充
图像处理之图像平移
一叶_障目
01-18 4910
图像平移：将图像上的所有像素点按照给定的偏移量移动，平移不改变图像内容，只改变图像位置 %% 函数解析 % 产生转换结构 TForm = maketform(TransformType) 其中：TransformType可取'affine'、'profective'、'custom'、'box'、'composite' % 平移变换 NewImage = imtransform(OldImage, TForm , ...)
图像处理基础操作一(几何变换、平滑处理、形态学操作)
热门推荐
Asia-Lee
11-06 2万+
一、图像基础 图像处理：对输入的图像做某种变换，输出仍然是图像，基本不涉及或者很少涉及图像内容的分析。比较典型的有图像变换，图像增强，图像去噪，图像压缩，图像恢复，二值图像处理等等。基于阈值的图像分割也属于图像处理的范畴。一般处理的是单幅图像。 图像分析：对图像的内容进行分析，提取有意义的特征，以便于后续的处理。处理的仍然是单幅图像。 计算机视觉：对图像分析得到的特征进行分析，提取场景的语义表示，让计算机具有人眼和人脑的能力。这时处理的是多幅图像或者序列图像，当然也包括部分单幅图像。 图像都是由像素
C# 图像几何运算（平移 镜像 缩放 旋转）
11-05
本主题将深入探讨如何使用C#实现图像的几何运算，包括平移、镜像、缩放和旋转。这些操作对于创建动态效果、调整图像大小以及实现图像变换功能至关重要。 首先，我们来看图像的平移操作。平移是指在二维空间内移动...
几何变换 图像平移 垂直镜像 水平镜像 图像转置 图像缩放 图像旋转.rar
09-07
本项目基于VS2017开发，提供了一组完整的图像处理功能，包括图像平移、垂直镜像、水平镜像、图像转置和图像缩放以及图像旋转。下面我们将详细讨论这些知识点。 1. **图像平移**：图像平移是指将图像在二维空间中...
C#图像处理初学之平移和镜像
qwezhaohaihong
02-09 5174
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.W
几何变换详解：平移、缩放、旋转
我的AI笔记
04-23 7127
介绍三种主要的几何变换：平移、缩放、旋转。 平移变换 将三维空间中的一个点 [x,y,z,1][x, y, z, 1][x,y,z,1] 移动到另外一个点 [x′,y′,z′,1][x', y', z', 1][x′,y′,z′,1] ，三个坐标轴的移动分量分别为 dx=Tx,dy=Ty,dz=Tzdx=Tx, dy=Ty, dz=Tzdx=Tx,dy=Ty,dz=Tz , 即 x′=x+Txx'...
图像的平移、旋转、缩放
@fei
09-13 5499
原理： 平移的矩阵： ⎡⎣⎢100010xy1⎤⎦⎥[10x01y001] \left[ \begin{array}{ccc} 1&amp;0&amp;x\\ 0&amp;1&amp;y\\ 0&amp;0&amp;1 \end{array} \right] 缩放的矩阵： ⎡⎣⎢a000b0001⎤⎦⎥[a000b0001] \left[ \begin{array}{ccc} a&amp;0&amp;0\\
emgu加载图片，图片的缩放和平移
qq_36786800的博客
05-21 1161
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using Emgu.CV; ...
图像几何变换之平移
qq_39507445的博客
01-09 7757
图像的几何变换 一、引言 打开任意一个图像的编辑器，一般都可以进行对图像进行放大、缩小、旋转等操作，这类操作改变了原图中各区域的空间关系。对于这类操作，通常称为图像的几何变换。 完成一张图像的几何变换需要两个独立的算法。首先，需要一个算法实现空间坐标变换，用它描述每个像素如何从初始位置移动到终止位置；其次，还需一个插值算法完成输出图像的每个像素的灰度值。 二、图像平移的原理 平移
C# Roberts 算法图像边缘检测-学习笔记
GshMissZL的博客
10-07 2378
转载请注明出处 by GshMissZL,我自己通过《C#数字图像处理算法典型实例》这本书学习，Roberts这个算法我按照书上输入之后不能很好的处理图像，下面是一些修改的部分。这是全部代码的一部分，给其他遇到同样问题的人提供个思路，（初学者，忘指正）
图像的几何运算
御坂御坂001的博客
12-10 1391
文章目录1.图像的插值 图像的几何运算是指引起图像几何形状发生改变的变换。与点运算不同的是，几何运算可以看成是像素在图像内的移动过程，该移动过程可以改变图像中物体对象之间的空间关系。 1.图像的插值 图像插值是指利用已知邻近像素点的灰度值来产生位置像素点的灰度值，以便由原始图像再生成具有更高分辨率的图像。插值是在不生成新的像素的情况下对原图像的像素重新分布，从而改变像素数量的一种方法。在图像放大过...
MATLAB图像几何变换：平移、旋转与缩放
"本资料详细介绍了MATLAB中的图像几何变换，包括平移、旋转、镜像变换、转置和放缩等操作。通过矩阵运算，这些变换变得简单易行。平移变换是最基础的一种，其逆变换对于确定新图像中像素对应原图像的位置至关重要。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值