数字图像处理总结(五)

已于 2022-12-23 11:15:50 修改
阅读量405 收藏
点赞数 2
分类专栏： 课程学习-数字图像处理DIP 文章标签： 计算机视觉 图像处理
于 2021-01-01 15:31:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36306288/article/details/111832114
版权

数字图像处理总结（五）

Part6 图像分割 image segmentation

主要内容包括一些点、线、边缘的检测算子和检测原理。
在这里插入图片描述

点、线、边缘的检测 point line edge detection

基本思想

根据其变化程度，使用梯度或者Laplace算子来进行检测，再进行阈值筛选；
一般而言，一阶导数产生的边缘比较粗糙；二阶导数产生的边缘比较精细，如细线、孤立点和噪声；
在这里插入图片描述

孤立点的检测

基本原理

使用Laplace算子进行检测，再进行阈值筛选即可
在这里插入图片描述
在这里插入图片描述

直线的检测

基本原理

使用方向算子进行检测，再进行阈值筛选即可
在这里插入图片描述

边缘的检测

三步：1、平滑；2、检测；3、边缘定位； 梯度与边缘方向垂直

梯度算子
  1. 先高斯滤波，去除噪声；然后使用梯度算子进行检测，阈值筛选法
    在这里插入图片描述
  2. 先高斯滤波，去除噪声；再使用梯度算子检测，zero crossing法
byte[,] zeroCross(float[,] f,float thr)  // 
{
   int w = f.GetLength(0);
   int h = f.GetLength(1);

   byte[,] g = new byte[w,h];

   for(int y=1;y<h-1;y++)
      for (int x=1;x<w-1;x++)
      {
         if (f[x,y]>=0)
         {
              if (f[x+1,y]*f[x-1,y]<0 && Math.Abs(f[x+1,y]-f[x-1,y])>thr) g[x,y]=255;
              if (f[x,y+1]*f[x,y-1]<0 && Math.Abs(f[x,y+1]-f[x,y-1])>thr) g[x,y]=255;
         } 
      }

   return g;

}
canny

在这里插入图片描述

float[,] filter2D(float[,]f,float[,] mask)
{
   int w = f.GetLength(0);
   int h = f.GetLength(1);

   float[,] g = new float[w,h];

   int M = mask.GetLength(0)/2;
   int N = mask.GetLength(1)/2;


   for(int y=N;y<h-N;y++)
      for (int x=M;x<w-M;x++)
      {
  float r = 0;
  for (int m=-M;m<=M;m++)
    for (int n=-N;n<=N;n++)
    {
    r+=f[x+m,y+n]*mask[M+m,N+n];
    }
       g[x,y] = r;  
    }

   return g;
}

byte S(double v)
{
   if (v<0) return 0;
   if (v>255) return 255;
   return (byte)v;

}

float[,] gblurMask(double r)
{
   int M = (int)(r*3);
   if (M==0) M=1;
   int N = M;  
   
   float[,] mask = new float[2*M+1,2*N+1];

  // sampling

   for (int m=-M;m<=M;m++)
      for (int n=-N;n<=N;n++)
         mask[M+m,N+n] = (float)Exp(-(m*m+n*n)/(2*r*r));

   // normalized
   float s = 0;

   for (int m=-M;m<=M;m++)
      for (int n=-N;n<=N;n++)
         s+=mask[M+m,N+n];

   for (int m=-M;m<=M;m++)
      for (int n=-N;n<=N;n++)
         mask[M+m,N+n] = mask[M+m,N+n]/s;



   return mask;
}

float[,] sobelX()
{
   float[,] mask = new float[3,3];

   mask[0,0] =-1;    mask[1,0] =  0;   mask[2,0] = 1;  
   mask[0,1] =-2;    mask[1,1] =  0;   mask[2,1] = 2;  
   mask[0,2] =-1;    mask[1,2] =  0;   mask[2,2] = 1;  


  return mask;
}

float[,] sobelY()
{
   float[,] mask = new float[3,3];

   mask[0,0] =-1;    mask[1,0] = -2;   mask[2,0] =-1;  
   mask[0,1] = 0;    mask[1,1] =  0;   mask[2,1] = 0;   
   mask[0,2] = 1;    mask[1,2] =  2;   mask[2,2] = 1;  


  return mask;
}

float[,] getMag(float[,]gx,float[,]gy)
{
  int w = gx.GetLength(0);
  int h = gx.GetLength(1);

  float[,] g = new float[w,h];  


  for (int y=0;y<h;y++)
     for (int x=0;x<w;x++)   
         g[x,y] = (float)Sqrt(gx[x,y]*gx[x,y]+gy[x,y]*gy[x,y]);   

  return g;
    
}

// return value is 0,1,2 or 3 
byte[,] getDir(float[,]gx,float[,]gy)
{
  int w = gx.GetLength(0);
  int h = gx.GetLength(1);

  byte[,] g = new byte[w,h];  

  for (int y=0;y<h;y++)
     for (int x=0;x<w;x++)
     {
         double max = Math.Abs(gx[x,y]);   

         double v = Math.Abs(gx[x,y]+gy[x,y])*0.707f;
         if (v>max)
         {
            g[x,y] = 1;
            max = v;
         } 

         v = Math.Abs(gy[x,y]);
         if (v>max)
         {
            g[x,y] = 2;
            max = v;
         } 

         v = Math.Abs(gx[x,y]-gy[x,y])*0.707f;
         if (v>max)
         {
            g[x,y] = 3;
            max = v;
         } 
     } 

  return g;
}

float[,] NMS(float[,]mag,byte[,]dir)
{
  int w = mag.GetLength(0);
  int h = mag.GetLength(1);

  float[,] g = new float[w,h];  


  for (int y=1;y<h-1;y++)
     for (int x=1;x<w-1;x++)
     {
        if (dir[x,y]==0 && mag[x,y]>mag[x-1,y] && mag[x,y]>mag[x+1,y]) g[x,y]=mag[x,y];
        if (dir[x,y]==1 && mag[x,y]>mag[x-1,y-1] && mag[x,y]>mag[x+1,y+1]) g[x,y]=mag[x,y];
        if (dir[x,y]==2 && mag[x,y]>mag[x,y-1] && mag[x,y]>mag[x,y+1]) g[x,y]=mag[x,y];
        if (dir[x,y]==3 && mag[x,y]>mag[x+1,y-1] && mag[x,y]>mag[x-1,y+1]) g[x,y]=mag[x,y];
     }   
  return g;
}

// return 255:strong edge, 128:weak edge,  0: 
byte[,] d_thr(float[,]f,float thr1,float thr2)
{
   int w = f.GetLength(0);
   int h = f.GetLength(1);

   byte[,] g = new byte[w,h];

   for(int y=0;y<h;y++)
      for (int x=0;x<w;x++)
        if (f[x,y]>thr1) g[x,y] = 255;
        else if (f[x,y]>thr2) g[x,y] = 128;

   return g;
}

bool connect_to_strong_edge(byte[,]f, int x,int y)
{
   for (int j=-1;j<=1;j++)
      for (int i=-1;i<=1;i++)
         if (f[x+i,y+j]==255) return true;

   return false;
}

void Label(byte [,] f, int x,int y)
{
  f[x,y] = 255;
  
  if (f[x+1,y]==128) Label(f,x+1,y);
  if (f[x-1,y]==128) Label(f,x-1,y);
  if (f[x,y+1]==128) Label(f,x,y+1);
  if (f[x,y-1]==128) Label(f,x,y-1);

  if (f[x-1,y-1]==128) Label(f,x-1,y-1);
  if (f[x+1,y-1]==128) Label(f,x+1,y-1);
  if (f[x-1,y+1]==128) Label(f,x-1,y+1);
  if (f[x+1,y+1]==128) Label(f,x+1,y+1);
}


byte[,] CA(byte[,]f)
{
   int w = f.GetLength(0);
   int h = f.GetLength(1);

   for(int y=0;y<h;y++)
      for (int x=0;x<w;x++)
          if (f[x,y]==128 && connect_to_strong_edge(f,x,y))
          {
              Label(f,x,y);
          } 
 
   byte[,] g = new byte[w,h];

   for(int y=0;y<h;y++)
      for (int x=0;x<w;x++)
        if (f[x,y]==255) g[x,y] = 255;

   return g;
}

float[,] ToFloat(byte[,]f)
{
   int w = f.GetLength(0);
   int h = f.GetLength(1);

   float[,] g = new float[w,h];

   for(int y=0;y<h;y++)
      for (int x=0;x<w;x++)
      {
         g[x,y] = f[x,y]; 
      }

   return g;
}

byte[,] ToByte(float[,]f,float off)
{
   int w = f.GetLength(0);
   int h = f.GetLength(1);

   byte[,] g = new byte[w,h];

   for(int y=0;y<h;y++)
      for (int x=0;x<w;x++)
      {
         g[x,y] = S(f[x,y]+off); 
      }

   return g;
}



void main()
{
   byte[,] f = LoadImg();
   ShowImg("f",f);

   float[,] g = filter2D(ToFloat(f),gblurMask(2));
   ShowImg("r=2",ToByte(g,0));

   float[,] gx = filter2D(g,sobelX());
   ShowImg("gx",ToByte(gx,128));

   float[,] gy = filter2D(g,sobelY());
   ShowImg("gy",ToByte(gy,128));

   float[,] mag = getMag(gx,gy);
   ShowImg("mag",ToByte(mag,0));

   byte[,] dir = getDir(gx,gy);

   float[,] nms = NMS(mag,dir);
   ShowImg("nms",ToByte(nms,0));

   byte[,] edge = d_thr(nms,32,16);
   ShowImg("edge",edge);

   ShowImg("final edge",CA(edge));

}

Part7 表示与描述

霍夫变换 hough transformation

检测VLIine

基本原理：计算每一列（x=x0）下图像像素点的和，记录在p数组里面，之后遍历p，找到最大的列即为所在的垂直线段；

int detectVLine(byte[,]f)
{
   int w = f.GetLength(0); 
   int h = f.GetLength(1);

   int[] p = new int[w];

   for (int y=0;y<h;y++)
     for (int x=0;x<w;x++)
         p[x]+=f[x,y]; 

  int max = 0;
  int x0 = 0;

  for (int x=0;x<w;x++)
     if (p[x]>max)
     {
         max = p[x];
         x0 = x;
     }

  return x0;    
}

void drawVLine(byte[,]f,int x0)
{
   int w = f.GetLength(0); 
   int h = f.GetLength(1);

   for (int y=0;y<h;y++)
      f[x0,y] = 255; 

}

霍夫变换检测直线

原理：

  1. 将角度细分为360°，构建一个二维数组，然后使用下式求可能的所有，ρθ的数量，放在数组里面：
    在这里插入图片描述
    2.对图像上的每个点，若像素值=255，则遍历所有的θ（n=0-359）计算ρ，将计算得到的ρ取整，ρ对应数组下标的元素++；
 int[,] hough(byte[,]f)
{
   double pi = 3.1415926;

   int w= f.GetLength(0);   
   int h= f.GetLength(1);   

   int[,] ps = new int[360,w+h];

   for (int y=0;y<h;y++)
     for (int x=0;x<w;x++)
     {
        if (f[x,y]==255)
        for (int a=0;a<360;a++)
        {
           int r = (int)(x*Cos(a*pi/180)+y*Sin(a*pi/180)); 
  
           if (r>=0 && r<w+h) 
           {
               ps[a,r] += 1;
            } 
        }    

     }
   return ps; 
}
  1. 遍历二维数组的每个数，找到最大的ρθ组合，即为检测到的直线。
 void get_params(int[,] ps,out int a0,out int r0)
{
   int w= ps.GetLength(0);   
   int h= ps.GetLength(1);   
   int max = 0;
   a0 = 0;
   r0 = 0;

   for (int r=0;r<h;r++)
      for (int a=0;a<w;a++)
      {
         if (ps[a,r]>max)
         {
            max = ps[a,r];
            a0 = a;
            r0 = r; 
         }
      }
}
  1. 若要查看具体的ps数组图像，需要先找到其最大值，然后归一化到0-255 即可。
 byte[,] toByte(int[,]f)
{
   int w = f.GetLength(0);
   int h = f.GetLength(1);

   byte[,] g = new byte[w,h];

   int max = 0;

   for(int y=0;y<h;y++)
      for (int x=0;x<w;x++)
          if (f[x,y]>max) max = f[x,y];

   for(int y=0;y<h;y++)
      for (int x=0;x<w;x++)
          g[x,y] = (byte)(f[x,y]*255/max);
   return g;
}
霍夫变换检测45°直线

这个时候直线式45°，因此与之垂直的过原点的直线的角度为135°，因此，a=135,然后遍历所有的θ，看看在a=135的时候，那个r最大；

int hough(byte[,]f)
{
   double pi = 3.1415926;

   int w= f.GetLength(0);   
   int h= f.GetLength(1);   

   int[] ps = new int[w+h];

   for (int y=0;y<h;y++)
     for (int x=0;x<w;x++)
     {
        int a = 135;   // 指定 a = 135 (即180-45)
        if (f[x,y]==255)
           int r = (int)(x*Cos(a*pi/180)+y*Sin(a*pi/180)); 
  
           if (r>=0 && r<w+h) 
           {
               ps[r] += 1;
            } 
        }    
     }

   int max = 0;
   int r0 = 0;

   for (int r=0;r<w+h;r++)
   {
      if (ps[r]>max)
      {
         max = ps[r];
         r0 = r; 
      }
   }

   return r0; 
}
霍夫圆变换

原理：和直线检测类似，都是在某个寻找最有可能的参数空间，直线式ρ，θ；那么圆就是圆心(x0,y0)和半径r;代码如下:

int[,,] hough(byte[,]f,int x0_min,int x0_max,int y0_min,int y0_max,int r_min,int r_max)
{
   //double pi = 3.1415926;

   int w= f.GetLength(0);   
   int h= f.GetLength(1);   

   int[,,] ps = new int[x0_max-x0_min,y0_max-y0_min,r_max-r_min];

   for (int y=0;y<h;y++)
     for (int x=0;x<w;x++)
     {
        if (f[x,y]==255)
        for (int x0=x0_min;x0<x0_max;x0++)
        for (int y0=y0_min;y0<y0_max;y0++)
        {
           int r = (int)(Sqrt((x-x0)*(x-x0)+(y-y0)*(y-y0))); 
  
           if (r>=r_min && r<r_max) 
           {
               ps[x0-x0_min,y0-y0_min,r-r_min] += 1;
            } 
        }    

     }
   return ps; 
}

void get_params(int[,,] ps,int x0_min,int y0_min,int r_min, out int x0,out int y0,out int r)
{
   int w= ps.GetLength(0);   
   int h= ps.GetLength(1);   
   int d= ps.GetLength(2);
   
   int max = 0;
   x0 = 0;
   y0 = 0;
   r = 0;

   for (int x=0;x<w;x++)
      for (int y=0;y<w;y++)
      for (int _r=0;_r<d;_r++)  
      {
         if (ps[x,y,_r]>max)
         {
            max = ps[x,y,_r];
            x0 = x;
            y0 = y;
            r = _r; 
         }
      }

  x0+=x0_min;
  y0+=y0_min;
  r+=r_min;
}

2维中心矩（质心） 2D central moment

基本原理：计算加权平均值
在这里插入图片描述
在这里插入图片描述

void GetCenter(byte[,]f,out int x0,out int y0)
{
   int w = f.GetLength(0);
   int h = f.GetLength(1);

   int m00 = 0;  // 这里用int不是很严谨，用double比较严谨，int有可能会溢出
   int m10 = 0;
   int m01 = 0;

   for (int y=0;y<h;y++)
      for (int x=0;x<w;x++)
      {
          m00 += f[x,y];
          m10 += x*f[x,y];
          m01 += y*f[x,y];  
      }

   x0 = m10/m00;      
   y0 = m01/m00;      
}

void main()
{
   byte[,] f = LoadImg();
   ShowImg("f",f);

   int x0,y0;

   GetCenter(f,out x0,out y0);

   f[x0,y0] = 0;
   ShowImg("center",f);
}

主要参考

百年后封笔
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
数字图像处理知识点总结.zip
10-04
数字图像处理的知识点总结，内容精炼，无论是考前复习还是半/开卷查看，都非常的不错，本人靠该总结得分90+。
数字图像处理总结
knight7765的博客
01-07 1429
数字图像处理重点总结 入门篇 图像处理综述： 图像增强：为了某种目的而处理图像，是处理后的图像比原始数据更易于处理。该过程比较主观，所以没有通用的理论来处理此过程。 图像复原：倾向于用以某种图像退化的数学和概率模型为基础。 小波：以不同分辨率来描述图像的基础 形态学处理：提取图像分量；图像分量用于表示和描述的输入。从图像分析一些特征。 分割：图像处理中最困难的步骤之一，将一副图像分割成不同的目标区域，成功的分割是识别的关键部分。 表示和描述：分割之后的数据如何表示，通常用轮廓和区域两种方式描述；为了使分割
数字图像处理复习总结
热门推荐
sunshine_lyn的博客
01-03 4万+
复习着感觉记不住，于是乎，有了这篇博文，如果也同样选修了数字图像处理课程的小伙伴们可以参考一哈！ 纯手码字…逢考必过！ 概念 采样与量化 灰度变换缓慢的景物：粗采样、细量化 有大量细节变化的图像：细采样、粗量化 采样不够出现马赛克；量化不够出现假轮廓 锐化：突出灰度的过渡部分（增强图像的细节边缘和轮廓） 例：高通滤波、梯度算子、拉普拉斯算子 平滑：用于模糊处理和降低噪声 例：低通滤波...
数字图像处理期末复习总结
qq_53932746的博客
03-13 3409
第一章概述 1.1数字图像处理及特点 数字图像处理的特点：1.再现性2.灵活性3.处理信息量很大4.数字图像中各个像素相关性大5.数字图像占用的频带较宽 1.2数字图像处理系统 数字图像处理系统是由图像数字化设备、图像处理计算机和图像输出设备组成 图像数字化设备将模拟信号转化为数字信号，可以是扫描仪、数码相机与摄像机等 图像处理计算机系统是以软件方式完成对图像的各种处理和识别，是核心的部分 图像输出设备将图像处理的中间结果或最后结果显示或打印记录 数字图像处理系统的主要优点：1.精度高 2..
数字图像处理-基本知识总结
qiqibb的博客
08-11 8187
数字图像处理的基本知识解读
数字图像处理总结（冈萨雷斯版）
qq_43728886的博客
12-20 1万+
数字图像处理（冈萨雷斯版本）课程复习
数字图像处理学习总结.doc
06-25
数字图像处理学习总结.doc
数字图像处理期末总结文章
03-13
用心总结，超详细，希望大家能够考高分
数字图像处理复习总结.doc
06-25
数字图像处理复习总结
数字图像处理（总结）思维导图
04-04
个人总结的有关数字图像处理相关知识思维导图（需下载MindMaster软件）
目标检测发展概述
最新发布
qq_53324833的博客
05-01 1128
传统目标检测方法主要基于人手工设计的特征提取器和机器学习算法。这些方法使用人工定义的特征，如Haar特征和HOG特征等，结合分类器（如支持向量机、AdaBoost等）来检测和分类目标。其中，Haar特征是一种基于像素的特征描述符，最初由Viola和Jones在2001年提出，用于人脸检测。它能够有效地描述图像中的局部区域，因此也可以用于检测其他类型的目标。而HOG特征则是一种描述图像局部梯度信息的方法，通过计算图像局部区域的梯度方向直方图来表示图像特征。
人脸识别概念解析
mickey2007的博客
04-28 2494
人脸识别在我们的生活中随处可见，例如在大楼门禁系统中，它取代了传统的门禁卡或密码，提高了进出的便捷性和安全性。在商场安保方面，人脸识别被广泛应用于监控系统，有助于识别和跟踪潜在的犯罪嫌疑人或失踪人员，提升了安全防范的能力。另外，手机解锁也是人脸识别技术的重要应用之一，它为用户提供了一种快捷、便利的身份验证方式，替代了传统的密码或指纹识别。
计算机视觉（CV）简介
longe20111104的博客
04-30 725
快速准确的处理是一个挑战，因为它需要处理大量的数据并做出准确的判断。特征选择和提取：从图像中选择和提取有用的特征是计算机视觉技术的关键挑战之一。不同的图像可能包含不同的特征，如纹理、颜色、形状等，如何选择和提取这些特征是一个复杂的问题。可以处理复杂的图像特征：计算机视觉技术可以识别和分析图像中的复杂特征，比如物体、人物、背景等。它可以在几秒钟内识别和分析图像中的信息，并根据这些信息做出相应的决策。复杂性和多样性：计算机视觉技术需要处理复杂和多样化的图像数据，包括不同的光照条件、角度、尺寸和分辨率等。
根据标签最大层面ROI提取原始图像区域
weixin_73101319的博客
04-27 434
我们要实现的是：在标签文件上选出最大层面，然后把最大层面的ROI映射到原始图像区域，在原始图像上提裁剪出ROI区域，然后根据这个ROI，在其上面一层和下面一层，共裁剪出三张原始图像。说明第23张图像是ROI层面最大的图像，（准确应该是第24张，因为从0开始）筛选出标签图像中不为0的像素值最多的那张图像，就是层面最大的图像。根据最大层面的ROI，映射到对应的原始图像中，以及上一层和下一层。有两个文件，一个是nii的原始图像文件，一个是nii的标签文件。将原始图像和标签图像的像素值提取出来。
FPGA高端项目：FPGA帧差算法多目标图像识别+目标跟踪，提供11套工程源码和技术支持
qq_41667729的博客
04-28 1695
FPGA高端项目：FPGA帧差算法多目标图像识别+目标跟踪，提供11套工程源码和技术支持
VIT(transformer在计算机视觉方面的应用)
LIjin_1006的博客
04-30 844
patch_img = ops.reshape(patch, (patch_size, patch_size,3))#变形成(6,6,3)# print(patch_img.numpy().max(),type(patch_img))#每个小块图的像素大小都不一样。# 创建小区域图块(1,144,108)#原图(32,32,3),path_size=6,144是指144个小块,108是。#变形之后,(1,144,6*6*3),样本,小块,每个小块的像素值。
图像处理ASIC设计方法 笔记18 轮廓跟踪算法的硬件加速方案
danxutj的博客
04-27 634
图像处理ASIC设计方法 笔记18 轮廓跟踪算法的硬件加速方案
图像处理ASIC设计方法 笔记19 连通域标记ASIC系统设计
danxutj的博客
04-27 1219
图像处理ASIC设计方法 笔记19 连通域标记ASIC系统设计
Python 基于 OpenCV 视觉图像处理实战 之 OpenCV 简单人脸检测/识别实战案例 之九 简单进行嘴巴检测并添加特效的功能实现
仙魁XAN
04-29 1385
Python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。Python是一种解释型脚本语言，可以应用于以下领域： Web 和 Internet开发、科学计算和统计、人工智能、教育、桌面界面开发、软件开发、后端开发、网络爬虫。这里使用 Python 基于 OpenCV 进行视觉图像处理，......
数字图像处理+dsp
12-27
数字图像处理（Digital Image Processing）是通过计算机对图像进行去除噪声、增强、分割、特征提取...总结起来，数字图像处理与DSP的结合可以实现高性能、高清晰度的图像处理系统，满足人们对计算机视频应用的高要求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

百年后封笔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值