C# 指针操作图像 细化处理

        /// <summary>
        /// 图形细化
        /// </summary>
        /// <param name="srcImg"></param>
        /// <returns></returns>
        public unsafe Bitmap ToThinner(Bitmap srcImg)
        {
            int iw = srcImg.Width;
            int ih = srcImg.Height;
            bool bModified;     //二值图像修改标志
            bool bCondition1;   //细化条件1标志
            bool bCondition2;   //细化条件2标志
            bool bCondition3;   //细化条件3标志
            bool bCondition4;   //细化条件4标志
            int nCount;
            //5X5像素块
            byte[,] neighbour = new byte[5, 5];
            //新建临时存储图像
            Bitmap NImg = new Bitmap(iw, ih, srcImg.PixelFormat);
            bModified = true;
            //细化修改标志, 用作循环条件
            BitmapData dstData = srcImg.LockBits(new Rectangle(0, 0, iw, ih), ImageLockMode.ReadWrite, srcImg.PixelFormat);
            byte* data = (byte*)(dstData.Scan0);
            //将图像转换为0,1二值得图像;
            int step = dstData.Stride;
            for (int i = 0; i < dstData.Height; i++)
            {
                for (int j = 0; j < dstData.Width * 3; j += 3)
                {
                    if (data[i * step + j] > 128)
                        //如果是白线条,只要将0改成1,将1改成0
                        data[i * step + j]
                            = data[i * step + j + 1]
                            = data[i * step + j + 2]
                            = 0;
                    else
                        data[i * step + j]
                            = data[i * step + j + 1]
                            = data[i * step + j + 2]
                            = 1;
                }
            }

            BitmapData dstData1 = NImg.LockBits(new Rectangle(0, 0, iw, ih), ImageLockMode.ReadWrite, NImg.PixelFormat);
            byte* data1 = (byte*)(dstData1.Scan0);
            int step1 = dstData1.Stride;
            //细化循环开始
            while (bModified)
            {
                bModified = false;
                //初始化临时二值图像NImg
                for (int i = 0; i < dstData1.Height; i++)
                {
                    for (int j = 0; j < dstData1.Width * 3; j++)
                    {
                        data1[i * step1 + j] = 0;
                    }
                }
                for (int i = 2; i < ih - 2; i++)
                {
                    for (int j = 6; j < iw * 3 - 6; j += 3)
                    {
                        bCondition1 = false;
                        bCondition2 = false;
                        bCondition3 = false;
                        bCondition4 = false;
                        if (data[i * step + j] == 0)
                            //若图像的当前点为白色,则跳过
                            continue;
                        for (int k = 0; k < 5; k++)
                        {
                            //取以当前点为中心的5X5块
                            for (int l = 0; l < 5; l++)
                            {
                                //1代表黑色, 0代表白色
                                //neighbour[k, l] = bw[i + k - 2, j + l - 2];
                                //neighbour[k, l] = data[(i + k - 2) * step + (j + l - 2)];
                                neighbour[k, l] = data[(i + k - 2) * step + (j + l * 3 - 6)];
                            }
                        }
                        //(1)判断条件2<=n(p)<=6
                        nCount = neighbour[1, 1] + neighbour[1, 2] + neighbour[1, 3] + neighbour[2, 1] + neighbour[2, 3] + neighbour[3, 1] + neighbour[3, 2] + neighbour[3, 3];
                        if (nCount >= 2 && nCount <= 6)
                            bCondition1 = true;
                        else
                        {
                            data1[i * step1 + j] = 1;
                            continue;
                            //跳过, 加快速度
                        }
                        //(2)判断s(p)=1
                        nCount = 0;
                        if (neighbour[2, 3] == 0 && neighbour[1, 3] == 1)
                            nCount++;
                        if (neighbour[1, 3] == 0 && neighbour[1, 2] == 1)
                            nCount++;
                        if (neighbour[1, 2] == 0 && neighbour[1, 1] == 1)
                            nCount++;
                        if (neighbour[1, 1] == 0 && neighbour[2, 1] == 1)
                            nCount++;
                        if (neighbour[2, 1] == 0 && neighbour[3, 1] == 1)
                            nCount++;
                        if (neighbour[3, 1] == 0 && neighbour[3, 2] == 1)
                            nCount++;
                        if (neighbour[3, 2] == 0 && neighbour[3, 3] == 1)
                            nCount++;
                        if (neighbour[3, 3] == 0 && neighbour[2, 3] == 1)
                            nCount++;
                        if (nCount == 1)
                            bCondition2 = true;
                        else
                        {
                            data1[i * step1 + j] = 1;
                            continue;
                        }
                        //(3)判断p0*p2*p4=0 or s(p2)!=1
                        if (neighbour[2, 3] * neighbour[1, 2] * neighbour[2, 1] == 0)
                            bCondition3 = true;
                        else
                        {
                            nCount = 0;
                            if (neighbour[0, 2] == 0 && neighbour[0, 1] == 1)
                                nCount++;
                            if (neighbour[0, 1] == 0 && neighbour[1, 1] == 1)
                                nCount++;
                            if (neighbour[1, 1] == 0 && neighbour[2, 1] == 1)
                                nCount++;
                            if (neighbour[2, 1] == 0 && neighbour[2, 2] == 1)
                                nCount++;
                            if (neighbour[2, 2] == 0 && neighbour[2, 3] == 1)
                                nCount++;
                            if (neighbour[2, 3] == 0 && neighbour[1, 3] == 1)
                                nCount++;
                            if (neighbour[1, 3] == 0 && neighbour[0, 3] == 1)
                                nCount++;
                            if (neighbour[0, 3] == 0 && neighbour[0, 2] == 1)
                                nCount++;
                            if (nCount != 1)
                                //s(p2)!=1
                                bCondition3 = true;
                            else
                            {
                                data1[i * step1 + j] = 1;
                                continue;
                            }
                        }
                        //(4)判断p2*p4*p6=0 or s(p4)!=1
                        if (neighbour[1, 2] * neighbour[2, 1] * neighbour[3, 2] == 0)
                            bCondition4 = true;
                        else
                        {
                            nCount = 0;
                            if (neighbour[1, 1] == 0 && neighbour[1, 0] == 1)
                                nCount++;
                            if (neighbour[1, 0] == 0 && neighbour[2, 0] == 1)
                                nCount++;
                            if (neighbour[2, 0] == 0 && neighbour[3, 0] == 1)
                                nCount++;
                            if (neighbour[3, 0] == 0 && neighbour[3, 1] == 1)
                                nCount++;
                            if (neighbour[3, 1] == 0 && neighbour[3, 2] == 1)
                                nCount++;
                            if (neighbour[3, 2] == 0 && neighbour[2, 2] == 1)
                                nCount++;
                            if (neighbour[2, 2] == 0 && neighbour[1, 2] == 1)
                                nCount++;
                            if (neighbour[1, 2] == 0 && neighbour[1, 1] == 1)
                                nCount++;
                            if (nCount != 1)//s(p4)!=1
                                bCondition4 = true;
                        }
                        if (bCondition1 && bCondition2 && bCondition3 && bCondition4)
                        {
                            data1[i * step1 + j] = 0;
                            bModified = true;
                        }
                        else
                        {
                            data1[i * step1 + j] = 1;
                        }
                    }
                }
                // 将细化了的临时图像bw_tem[w,h]copy到bw[w,h],完成一次细化
                for (int i = 2; i < ih - 2; i++)
                    for (int j = 2; j < iw * 3 - 2; j++)
                        data[i * step + j] = data1[i * step1 + j];
            }
            for (int i = 2; i < ih - 2; i++)
            {
                for (int j = 6; j < iw * 3 - 6; j += 3)
                {
                    if (data[i * step + j] == 1)

                        data[i * step + j]
                            = data[i * step + j + 1]
                            = data[i * step + j + 2]
                            = 0;

                    else

                        data[i * step + j]
                            = data[i * step + j + 1]
                            = data[i * step + j + 2]
                            = 255;

                }
            }
            srcImg.UnlockBits(dstData);
            NImg.UnlockBits(dstData1);
            return (srcImg);
        }
时间: 2024-10-26 12:39:53

C# 指针操作图像 细化处理的相关文章

C# 指针操作图像 二值化处理

/// <summary> /// 二值化图像 /// </summary> /// <param name="bmp"></param> /// <returns></returns> private static unsafe Bitmap Binaryzation(Bitmap bmp) { BitmapData dstData = bmp.LockBits(new Rectangle(0, 0, bmp.W

【MATLAB】图像细化算法

细化算法 图像细化(Image Thinning),一般指二值图像的骨架化(Image Skeletonization)的一种操作运算. 所谓的细化就是经过一层层的剥离,从原来的图中去掉一些点,但仍要保持原来的形状,直到得到图像的骨架.骨架,可以理解为图象的中轴. 评价指标: 收敛性 保证细化后细线的连通性 保持原图的基本形状 减少笔画相交处的畸变 细化结果是原图像的中心线 细化的快速性和迭代次数少 其中: 非迭代算法: 一次即产生骨架,如基于距离变换的方法.游程长度编码细化等 迭代算法: 重复

【opencv】图像细化

[opencv]图像细化 [opencv]图像细化 2014-02-17 21:03 5404人阅读 评论(14) 收藏 举报  分类: opencv(1)  版权声明:本文为博主原创文章,未经博主允许不得转载. 在我们进行图像处理的时候,有可能需要对图像进行细化,提取出图像的骨架信息,进行更加有效的分析. 图像细化(Image Thinning),一般指二值图像的骨架化(Image Skeletonization) 的一种操作运算. 所谓的细化就是经过一层层的剥离,从原来的图中去掉一些点,但仍

【数字图像处理】图像细化处理

图像细化 细化技术:把一个平面区域简化成图的结构形状表示法骨架:一种细化结构,它是目标的重要拓扑描述,具有非常广泛的应用.在图像识别或数据压缩时,经常用细化结构.例如:在识别字符之前,往往要先对字符作细化处理,求出字符的细化结构.细化的作用:目的将图像的骨架提取出来的同时,保持图像细小部分的连通性,对被处理的图像进行细化有助于突出形状特点和减少冗余信息量. 细化算法 细化算法:采取逐次去除边界的方法进行的,不能破化图像的连通性.通常选择一组结构元素对,不断在这些结构对中循环,如果所得结果不再变化

数组与指针(四)——指针操作

// ptr_ops --指针 操作 #include<stdio.h>int main(void){   int urn[5] = {100,200,300,400,500}; int *ptr1,*ptr2,*ptr3; ptr1 = urn;       //把第个地址赋给指针    ptr2 = &urn[2];   //同上 printf("pointer value ,dereferenced pointer ,pointer address:/n");

Day4:T1小技巧(类似于指针操作)T2搜索+小细节

Day4:其中有很多小技巧get T1 一直没有听到过像这样的小技巧的略专业名词,有点类似于指针操作,之前有碰到过很多这样的题目 每次都是以不同的形式出现,但是感觉思想还是有点接近的吧(就比如某天有一题happy,貌似也是这类型的) 这类题目第一眼总是看起来特别的不能写,其实想到了这些技巧之后很简单 感觉这也没有什么规律性或是模板可言 大概的,就是指针思想+平时积累吧 说说这一题吧 在分析正解之前,我们先说一说比较容易想到的骗分方法 设男女人数相同时ans=0,如果下一个是男->ans++,el

C 语言中有趣第指针操作(转)

http://blog.csdn.net/ghevinn/article/details/37651149(反汇编题目需要分析) 4.取出内存区域的值 在取某内存地址开始的一个区域的值的时候,取出的值取决于用来取值的类型,譬如int为4个byte,char为1个byte,程序如: void main(){ int a[2] = {261,0}; int *pi = a; char *p = (char*)pi; cout << *(int *)p++ << endl;  //取出p

C#之指针操作

之前听人说C#没有指针,因为不安全,百度了一下是这么说的: 现在因为工作需要操作硬件看门狗,知道原来C#也是可以操作指针的. 程序环境:.NET MicroFramework 开发工具:VisualStudio 2013开发语言:C#通信工具:新生命神码工具 程序功能:我们的开发硬件在特殊外围情况下可能会出新死机现象.解决方法是通过看门狗程序发现死机,然后C#让MCU指针复位.让MCU重启. C#操作单片机指针程序操作如下: 代码: using System; using Microsoft.S

C#中对指针操作报错解决方法

(C#中实际不存在指针,这里是仿C语言中指针操作进行说明) 1.错误1      “指针和固定大小缓冲区只能在不安全的上下文中使用” 解决方法:在方法前加上unsafe关键字 2.错误2 “不安全代码只会在使用 /unsafe 编译的情况下出现” 解决方法:右键选中资源管理器中项目文件--属性--生成--勾选"允许不安全代码复选框"! 事例代码,取变量a的内存地址并输出: using System; using System.Collections.Generic; using Sys