AI 助理
备案控制台
开发者社区 人工智能 文章 正文

图像处理算法篇1

2011-02-21 624
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Alogrithm.h的全部程序如下: #ifndef ALGORITHM_H_INCLUDE#define ALGORITHM_H_INCLUDE #include #include "Bitmap.

Alogrithm.h的全部程序如下:


#ifndef ALGORITHM_H_INCLUDE
#define ALGORITHM_H_INCLUDE

#include <math.h>

#include "Bitmap.h"

//图像细化
int Thining(BYTE* image,DWORD dwWidth,DWORD dwHeight,WORD wBitCount)
{
 static int erasetable[256]={
  0,0,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,1,
  0,0,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,1,
  1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  1,1,0,0,1,1,0,0,1,1,0,1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,1,
  0,0,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0,
  1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0,
  1,1,0,0,1,1,0,0,1,1,0,1,1,1,0,0,1,1,0,0,1,1,1,0,1,1,0,0,1,0,0,0
 };

 DWORD dwLineBytes=(dwWidth*wBitCount+31)/32*4;
 BYTE *temp=NULL;
 DWORD i=0;
 DWORD j=0;
 BYTE g=0;
 BYTE zs=0,s=0,ys=0,z=0,y=0,zx=0,x=0,yx=0;
 int num=0;

 temp=(BYTE*)malloc(dwHeight*dwLineBytes*sizeof(BYTE));
 if(!temp)
 {
  return -1;
 }

 if(wBitCount!=8)
 {
  free(temp);
  temp=NULL;
  return -1;
 }

 for(i=0;i<dwHeight;i++)
 {
  for(j=0;j<dwWidth;j++)
  {
   g=*(image+dwLineBytes*i+j);
   if(g<=120)
   {
    *(image+dwLineBytes*i+j)=(BYTE)0;
   }
   else
   {
    *(image+dwLineBytes*i+j)=(BYTE)255;
   }
  }
 }

 memcpy(temp,image,dwLineBytes*dwHeight*sizeof(BYTE));

 for(i=1;i<dwHeight-1;i++)
 {
  for(j=1;j<dwWidth-1;j++)
  {
   g=*(image+dwLineBytes*i+j);
   if(g==0)
   {
    z=*(image+dwLineBytes*i+j-1);
    y=*(image+dwLineBytes*i+j+1);
    if(z==255 || y==255)
    {
     zs=*(image+dwLineBytes*(i+1)+j-1);
     s=*(image+dwLineBytes*(i+1)+j);
     ys=*(image+dwLineBytes*(i+1)+j+1);
     zx=*(image+dwLineBytes*(i-1)+j-1);
     x=*(image+dwLineBytes*(i-1)+j);
     yx=*(image+dwLineBytes*(i-1)+j+1);
     num=zs/255+s/255*2+ys/255*4+z/255*8+y/255*16+zx/255*32+x/255*64+yx/255*128;
     if(erasetable[num]==1)
     {
      *(temp+dwLineBytes*i+j)=(BYTE)255;
      *(image+dwLineBytes*i+j)=(BYTE)255;
     }
    }
   }
  }
 }

 for(i=1;i<dwHeight-1;i++)
 {
  for(j=1;j<dwWidth-1;j++)
  {
   g=*(image+dwLineBytes*i+j);
   if(g==0)
   {
    s=*(image+dwLineBytes*(i+1)+j);
    x=*(image+dwLineBytes*(i-1)+j);
    if(s==255 || x==255)
    {
     zs=*(image+dwLineBytes*(i+1)+j-1);
     z=*(image+dwLineBytes*i+j-1);
     y=*(image+dwLineBytes*i+j+1);
     ys=*(image+dwLineBytes*(i+1)+j+1);
     zx=*(image+dwLineBytes*(i-1)+j-1);
     yx=*(image+dwLineBytes*(i-1)+j+1);
     num=zs/255+s/255*2+ys/255*4+z/255*8+y/255*16+zx/255*32+x/255*64+yx/255*128;
     if(erasetable[num]==1)
     {
      *(temp+dwLineBytes*i+j)=(BYTE)255;
      *(image+dwLineBytes*i+j)=(BYTE)255;
     }
    }
   }
  }
 }

 memcpy(image,temp,dwHeight*dwLineBytes*sizeof(BYTE));
 free(temp);
 temp=NULL;
 return 0;
}

//图像膨胀
int Dilation(BYTE* image,DWORD dwWidth,DWORD dwHeight,WORD wBitCount,
     int type,int num)
{
 DWORD dwLineBytes=(dwWidth*wBitCount+31)/32*4;
 DWORD i=0;
 DWORD j=0;
 DWORD n=0;
 BYTE b=0;
 BYTE g=0;
 BYTE r=0;
 double avg=0;
 BYTE *temp=NULL;
 int k=0;

 if(image==NULL)
 {
  return -1;
 }
 if(num!=3 && num!=5 &&num!=7)
 {
  return -1;
 }

 temp=(BYTE*)malloc(dwHeight*dwLineBytes*sizeof(BYTE));
 if(!temp)
 {
  return -1;
 }
 memset(temp,255,dwLineBytes*dwHeight*sizeof(BYTE));

 if(wBitCount==8)
 {
  //如果为非二值图像，则转化为二值图像
  for(i=0;i<dwHeight;i++)
  {
   for(j=0;j<dwWidth;j++)
   {
    g=*(image+dwLineBytes*i+j);
    if(g>=120)
    {
     *(image+dwLineBytes*i+j)=255;
    }
    else
    {
     *(image+dwLineBytes*i+j)=0;
    }

   }
  }

  if(type==0)
  {
   //水平方向
   for(i=0;i<dwHeight;i++)
   {
    for(j=(num-1)/2;j<dwWidth-(num-1)/2;j++)
    {
     for(k=-(num-1)/2;k<=(num-1)/2;k++)
     {
      g=*(image+dwLineBytes*i+j+k);
      if(g==0)
      {
       *(temp+dwLineBytes*i+j)=0;
       break;
      }
     }
    }
   }
  }
  else
  {
   //垂直方向
   for(i=(num-1)/2;i<dwHeight-(num-1)/2;i++)
   {
    for(j=0;j<dwWidth;j++)
    {
     for(k=-(num-1)/2;k<=(num-1)/2;k++)
     {
      g=*(image+dwLineBytes*(i+k)+j);
      if(g==0)
      {
       *(temp+dwLineBytes*i+j)=0;
       break;
      }
     }
    }
   }
  }
 }
 else if(wBitCount==24)
 {
  //如果不是二值图像，需要先转换为二值图像
  for(i=0;i<dwHeight;i++)
  {
   for(j=0,n=0;j<dwWidth*3;j++,n++)
   {
    b=*(image+dwLineBytes*i+j);
    j++;
    g=*(image+dwLineBytes*i+j);
    j++;
    r=*(image+dwLineBytes*i+j);

    avg=(b+g+r)/3.0;

    if(avg>=120)
    {
     avg=255;
    }
    else
    {
     avg=0;
    }

    *(image+dwLineBytes*i+n)=(BYTE)avg;
    n++;
    *(image+dwLineBytes*i+n)=(BYTE)avg;
    n++;
    *(image+dwLineBytes*i+n)=(BYTE)avg;
   }
  }

  if(type==0)
  {
   //水平方向
   for(i=0;i<dwHeight;i++)
   {
    for(j=(num-1)/2;j<(dwWidth-(num-1)/2)*3;j++)
    {
     for(k=-(num-1)/2;k<=(num-1)/2;k++)
     {
      b=*(image+dwLineBytes*i+j+k*3);
      g=*(image+dwLineBytes*i+j+1+k*3);
      r=*(image+dwLineBytes*i+j+2+k*3);
      if(b==0 && g==0 && r==0)
      {
       *(temp+dwLineBytes*i+j)=0;
       j++;
       *(temp+dwLineBytes*i+j)=0;
       j++;
       *(temp+dwLineBytes*i+j)=0;
       break;
      }
     }
    }
   }
  }
  else
  {
   //垂直方向
   for(i=(num-1)/2;i<dwHeight-(num-1)/2;i++)
   {
    for(j=0;j<dwWidth*3;j++)
    {
     for(k=-(num-1)/2;k<=(num-1)/2;k++)
     {
      b=*(image+dwLineBytes*(i+k)+j);
      g=*(image+dwLineBytes*(i+k)+j+1);
      r=*(image+dwLineBytes*(i+k)+j+2);
      if(b==0 && g==0 && r==0)
      {
       *(temp+dwLineBytes*i+j)=0;
       j++;
       *(temp+dwLineBytes*i+j)=0;
       j++;
       *(temp+dwLineBytes*i+j)=0;
       break;
      }
     }
    }
   }
  }
 }
 else
 {
  free(temp);
  temp=NULL;
  return -1;
 }

 memcpy(image,temp,dwLineBytes*dwHeight*sizeof(BYTE));
 free(temp);
 temp=NULL;
 return 0;
}

//图像腐蚀
int Erosion(BYTE* image,DWORD dwWidth,DWORD dwHeight,WORD wBitCount,
    int type,int num)
{
 DWORD dwLineBytes=(dwWidth*wBitCount+31)/32*4;
 DWORD i=0;
 DWORD j=0;
 DWORD n=0;
 BYTE b=0;
 BYTE g=0;
 BYTE r=0;
 double avg=0;
 BYTE *temp=NULL;
 int k=0;

 if(image==NULL)
 {
  return -1;
 }
 if(num!=3 && num!=5 && num!=7)
 {
  return -1;
 }

 temp=(BYTE*)malloc(dwHeight*dwLineBytes*sizeof(BYTE));
 if(!temp)
 {
  return -1;
 }
 memset(temp,0,dwLineBytes*dwHeight*sizeof(BYTE));

 if(wBitCount==8)
 {
  //如果为非二值图像，则转化为二值图像
  for(i=0;i<dwHeight;i++)
  {
   for(j=0;j<dwWidth;j++)
   {
    g=*(image+dwLineBytes*i+j);
    if(g>=120)
    {
     *(image+dwLineBytes*i+j)=255;
    }
    else
    {
     *(image+dwLineBytes*i+j)=0;
    }

   }
  }

  if(type==0)
  {
   //水平方向
   for(i=0;i<dwHeight;i++)
   {
    for(j=(num-1)/2;j<dwWidth-(num-1)/2;j++)
    {
     for(k=-(num-1)/2;k<=(num-1)/2;k++)
     {
      g=*(image+dwLineBytes*i+j+k);
      if(g==255)
      {
       *(temp+dwLineBytes*i+j)=255;
       break;
      }
     }
    }
   }
  }
  else
  {
   //垂直方向
   for(i=(num-1)/2;i<dwHeight-(num-1)/2;i++)
   {
    for(j=0;j<dwWidth;j++)
    {
     for(k=-(num-1)/2;k<=(num-1)/2;k++)
     {
      g=*(image+dwLineBytes*(i+k)+j);
      if(g==255)
      {
       *(temp+dwLineBytes*i+j)=255;
       break;
      }
     }
    }
   }
  }
 }
 else if(wBitCount==24)
 {
  //如果不是二值图像，需要先转换为二值图像
  for(i=0;i<dwHeight;i++)
  {
   for(j=0,n=0;j<dwWidth*3;j++,n++)
   {
    b=*(image+dwLineBytes*i+j);
    j++;
    g=*(image+dwLineBytes*i+j);
    j++;
    r=*(image+dwLineBytes*i+j);

    avg=(b+g+r)/3.0;

    if(avg>=120)
    {
     avg=255;
    }
    else
    {
     avg=0;
    }

    *(image+dwLineBytes*i+n)=(BYTE)avg;
    n++;
    *(image+dwLineBytes*i+n)=(BYTE)avg;
    n++;
    *(image+dwLineBytes*i+n)=(BYTE)avg;
   }
  }

  if(type==0)
  {
   //水平方向
   for(i=0;i<dwHeight;i++)
   {
    for(j=(num-1)/2;j<(dwWidth-(num-1)/2)*3;j++)
    {
     for(k=-(num-1)/2;k<=(num-1)/2;k++)
     {
      b=*(image+dwLineBytes*i+j+k*3);
      g=*(image+dwLineBytes*i+j+1+k*3);
      r=*(image+dwLineBytes*i+j+2+k*3);
      if(b==255 && g==255 && r==255)
      {
       *(temp+dwLineBytes*i+j)=255;
       j++;
       *(temp+dwLineBytes*i+j)=255;
       j++;
       *(temp+dwLineBytes*i+j)=255;
       break;
      }
     }
    }
   }
  }
  else
  {
   //垂直方向
   for(i=(num-1)/2;i<dwHeight-(num-1)/2;i++)
   {
    for(j=0;j<dwWidth*3;j++)
    {
     for(k=-(num-1)/2;k<=(num-1)/2;k++)
     {
      b=*(image+dwLineBytes*(i+k)+j);
      g=*(image+dwLineBytes*(i+k)+j+1);
      r=*(image+dwLineBytes*(i+k)+j+2);
      if(b==255 && g==255 && r==255)
      {
       *(temp+dwLineBytes*i+j)=255;
       j++;
       *(temp+dwLineBytes*i+j)=255;
       j++;
       *(temp+dwLineBytes*i+j)=255;
       break;
      }
     }
    }
   }
  }
 }
 else
 {
  free(temp);
  temp=NULL;
  return -1;
 }

 memcpy(image,temp,dwLineBytes*dwHeight*sizeof(BYTE));
 free(temp);
 temp=NULL;
 return 0;
}

//图像开闭运算
int OpenClose(BYTE *image,DWORD dwWidth,DWORD dwHeight,WORD wBitCout,
      int type,int direction,int num)
{  
 if(num!=3 && num!=5 && num!=7)
 {
  return -1;
 }
 
 if(type==0)
 {//开运算
  Erosion(image,dwWidth,dwHeight,wBitCout,direction,num);
  Dilation(image,dwWidth,dwHeight,wBitCout,direction,num);
  return 0;
 }
 else
 {//闭运算
  Dilation(image,dwWidth,dwHeight,wBitCout,direction,num);
  Erosion(image,dwWidth,dwHeight,wBitCout,direction,num);
  return 0;
 }
}

//图像窗口变换
int WindowTranslation(BYTE *image,DWORD dwWidth,DWORD dwHeight,WORD wBitCount,
       int down,int up)
{
 DWORD height=dwHeight;
 DWORD width=dwWidth;
 WORD bitCount=wBitCount;
 DWORD lineBytes=(width*bitCount+31)/32*4;
 BYTE *temp=image;
 DWORD i=0;
 DWORD j=0;
 DWORD n=0;
 BYTE g=0;
 BYTE b=0;
 BYTE r=0;
 double avg=0;
 
 if(bitCount==8)
 {
  for(i=0;i<height;i++)
  {
   for(j=0;j<width;j++)
   {
    g=*(temp+lineBytes*(height-1-i)+j);
    if(g<down)
    {
     *(temp+lineBytes*(height-1-i)+j)=0;
    }
    if(g>up)
    {
     *(temp+lineBytes*(height-1-i)+j)=255;
    }
   }
  }
 }
 else if(bitCount==24)
 {
  for(i=0;i<height;i++)
  {
   for(j=0,n=0;j<width*3;j++,n++)
   {
    b=*(temp+lineBytes*i+j);
    j++;
    g=*(temp+lineBytes*i+j);
    j++;
    r=*(temp+lineBytes*i+j);
    
    avg=(b+g+r)/3.0;
    if(avg<down) avg=0;
    if(avg>up) avg=255;
    
    *(temp+lineBytes*i+n)=(BYTE)avg;
    n++;
    *(temp+lineBytes*i+n)=(BYTE)avg;
    n++;
    *(temp+lineBytes*i+n)=(BYTE)avg;
   }
  }
 }
 else
 {
  return -1;
 }

 return 0;
}

//图像对数变换
int LogTranslation(BYTE *image,DWORD dwWidth,DWORD dwHeight,WORD wBitCount,
       int k)
{
 DWORD height=dwHeight;
 DWORD width=dwWidth;
 WORD bitCount=wBitCount;
 DWORD lineBytes=(width*bitCount+31)/32*4;
 BYTE *temp=image;
 DWORD i=0;
 DWORD j=0;
 DWORD n=0;
 BYTE b=0;
 BYTE g=0;
 BYTE r=0;

 if(temp==NULL)
 {
  return -1;
 }
 
 if(bitCount==8)
 {
  for(i=0;i<height;i++)
  {
   for(j=0;j<width;j++)
   {
    g=*(temp+lineBytes*i+j);
    *(temp+lineBytes*i+j)=(BYTE)(k*log(g+1));
   }
  }
 }
 else if(bitCount==24)
 {
  for(i=0;i<height;i++)
  {
   for(j=0,n=0;j<width*3;j++,n++)
   {
    b=*(temp+lineBytes*i+j);
    j++;
    g=*(temp+lineBytes*i+j);
    j++;
    r=*(temp+lineBytes*i+j);
    
    *(temp+lineBytes*i+n)=(BYTE)(k*log(b+1));
    n++;
    *(temp+lineBytes*i+n)=(BYTE)(k*log(g+1));
    n++;
    *(temp+lineBytes*i+n)=(BYTE)(k*log(r+1));
   }
  }
 }
 else
 {
  return -1;
 }

 return 0;
}

文章标签：
计算机视觉
算法
关键词：
图像处理算法
孤独的猫董
目录
相关文章
opencv学堂
|
6月前
|
存储 算法 数据挖掘
图像处理之Fuzzy C Means的聚合算法
图像处理之Fuzzy C Means的聚合算法
opencv学堂
108 7
图像处理之Fuzzy C Means的聚合算法
opencv学堂
|
6月前
|
算法 计算机视觉
图像处理之积分图应用四（基于局部均值的图像二值化算法）
图像处理之积分图应用四（基于局部均值的图像二值化算法）
opencv学堂
554 0
opencv学堂
|
6月前
|
监控 算法 图计算
图像处理之积分图应用三（基于NCC快速相似度匹配算法）
图像处理之积分图应用三（基于NCC快速相似度匹配算法）
opencv学堂
83 0
opencv学堂
|
6月前
|
文字识别 算法 计算机视觉
图像处理之Zhang Suen细化算法
图像处理之Zhang Suen细化算法
opencv学堂
102 0
opencv学堂
|
6月前
|
算法 Java 计算机视觉
图像处理之泛洪填充算法(Flood Fill Algorithm)
图像处理之泛洪填充算法(Flood Fill Algorithm)
opencv学堂
307 6
opencv学堂
|
6月前
|
算法 计算机视觉
图像处理之角点检测算法(Harris Corner Detection)
图像处理之角点检测算法(Harris Corner Detection)
opencv学堂
61 3
opencv学堂
|
6月前
|
算法 Java 计算机视觉
图像处理之积分图算法
图像处理之积分图算法
opencv学堂
74 2
opencv学堂
|
6月前
|
算法 计算机视觉
图像处理之三种常见双立方插值算法
图像处理之三种常见双立方插值算法
opencv学堂
48 2
opencv学堂
|
6月前
|
算法 计算机视觉
图像处理之K-Means算法演示
图像处理之K-Means算法演示
opencv学堂
45 2
opencv学堂
|
6月前
|
算法 Java API
记录我第一次在Android开发图像处理算法的经历
记录我第一次在Android开发图像处理算法的经历
opencv学堂
42 1

热门文章

最新文章

  • 1
    领域最全 | 计算机视觉算法在路面坑洼检测中的应用综述(基于2D图像/3D LiDAR/深度学习)（下）
  • 2
    算法竞赛入门【码蹄集新手村600题】(MT1101-1150）
  • 3
    DL之ANN/DNN： 人工神经网络ANN/DNN深度神经网络算法的简介、应用、经典案例之详细攻略
  • 4
    openssl中算法的组织方式
  • 5
    iOS 算法之排序、查找、递归
  • 6
    指针难，算法难，难住了谁
  • 7
    OpenCV 1 图像分割--分水岭算法代码
  • 8
    多视图立体视觉: CVPR 2019 与 AAAI 2020 上的ACMH、ACMM及ACMP算法介绍
  • 9
    算法笔记之回溯法（2）
  • 10
    缓存、缓存算法(转)
  • 1
    BASE64的算法说明
    65
  • 2
    算法人生（1）：从“强化学习”看如何“战胜拖延”
    114
  • 3
    理解并应用机器学习算法：决策树
    144
  • 4
    【机器学习】在使用K-means聚类算法时，如何选择K的值？
    412
  • 5
    【机器学习】为什么K-means算法使用欧式距离度量？
    395
  • 6
    【机器学习】描述K-means算法的步骤
    153
  • 7
    【机器学习】K-means和KNN算法有什么区别？
    640
  • 8
    C语言易混淆、简单算法、结构体题目练习、常见关键字总结-2
    54
  • 9
    C语言易混淆、简单算法、结构体题目练习、常见关键字总结-1
    56
  • 10
    图搜索算法详解
    137

    • 相关课程

    更多
  • 智能运维赛（复赛）：利用数据和算法，快速定位系统异常并进行根因分析
  • 智能创作赛（复赛）：相册应用中的视频故事生成算法介绍
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • 数据+算法定义新世界
  • 袋鼠云基于实时计算的反黄牛算法
  • Alink：基于Apache Flink的算法平台

    • 相关实验场景

    更多
  • 使用Swing算法实现商品推荐
  • RSA密码算法设计与实现
  • 欧拉图的构造性证明与算法实现
  • 推荐系统入门之使用ALS算法实现打分预测
    • 下一篇
    DataWorks