2018-10-16 08:27:01 qq_33810188 阅读数 450
  • Tensorflow-图像处理视频教程

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 课程以图像处理软件Tensorflow作为核心武器,基于图像处理热点话题进行案例实战。选择当下热门模型,使用真实数据集进行实战演示,通俗讲解整个算法模型并使用tensorflow进行实战,详解其中的原理与代码实现。

    1388 人正在学习 去看看 唐宇迪

· 能从硬件结构方面消除不利影响,最好不要从图像算法方面消除不利影响(预防隐患法则)

· 截至目前为止,图像算法没有一个标准的算法流程适合所有的图像处理,所以具体问题具体分析

· 图像算法处理的实际应用遵循海森堡不确定性原则,所以在实际应用中不断优化算法十分必要

· 图像算法处理的实际应用符合墨菲定律,所以图像算法前期的设计隐患一定会在实际应用中产生

· 图像处理算法一定是定量分析算法,模糊不定的处理方式必然会导致问题

· 图像处理问题归根结底是一个数学问题,所以扎实的数学功底必不可少!

---------------------------------------------------------------------------------------------------------------

1.图像算法的设计一定要考虑数据结构类型,不友好的数据结构会使后续的代码结构十分繁琐冗余!

2.无论函数名,还是参数名,在取名的时候千万避免名称相似(例如,如果有一个camsPixels,不可再取一个camPixels,否则在查看代码时,直观上很容易分辨错误!浪费解读代码时间!);

3.不要重复命名函数,否则哪天封装多个带有重复名称的函数时,会出现命名冲突!

4.尽量不要重复造轮子,能够借鉴的代码要借鉴并优化,不断学习别人的代码风格和代码逻辑;

5.一位优秀的算法工程师,也必须是一位不错的软件工程师!

6.写算法跟写软件不一样,最直观的区别的是,写算法前要研读论文,写软件前要学教程;

7.算法必须站上软件的肩膀上才有价值!换句话说,算法要用优秀的软件程序表现出来才有意义;

8.算法开发前期一定要评估该算法的设计流程,对其采用的具体算法手段进行认真考量,要预先考虑到该算法在实际应用中可能存在的风险,以及相应的解决对策。不可盲目下手进行开发,否则非常浪费时间和精力;

9.图像处理中很多场景都是在浮点型下进行数据处理的,所以一定不要把整型、理论等思维强加要数据处理中,例如两条直线垂直,叉乘是为0,但是实际场景中的数据是浮点型,得到的结果并不绝对为0,所以需要设置一个很小的误差范围。诸如这样的问题,可以推广至很多场合,只要算法设计考虑够多的场景,兼顾更多的情况,最后算法才会更加鲁棒!

10.

 

 

2017-11-24 22:42:45 xxxqcbQ 阅读数 286
  • Tensorflow-图像处理视频教程

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 课程以图像处理软件Tensorflow作为核心武器,基于图像处理热点话题进行案例实战。选择当下热门模型,使用真实数据集进行实战演示,通俗讲解整个算法模型并使用tensorflow进行实战,详解其中的原理与代码实现。

    1388 人正在学习 去看看 唐宇迪

        一直想记录自己图像处理算法修炼心路历程,今天终于鼓足勇气写下第一篇,万事开头难。

        算法写了快4个月了,目前写的比较多的是基础算法,比如通用的圆、直线检测算法,还真不能小瞧这类算法,想在工程上做到又快又准,真的不是一件容易的事情。这里应该算是有bug的,又快又好应当有个明确的量化指标。

        对于圆检测的基本逻辑是:Sobel/Canny算子处理→拿出边界→边界筛选→最小二乘拟合(对噪声很敏感)。


2014-06-07 10:46:19 zhuangxiaobin 阅读数 2480
  • Tensorflow-图像处理视频教程

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 课程以图像处理软件Tensorflow作为核心武器,基于图像处理热点话题进行案例实战。选择当下热门模型,使用真实数据集进行实战演示,通俗讲解整个算法模型并使用tensorflow进行实战,详解其中的原理与代码实现。

    1388 人正在学习 去看看 唐宇迪

这是利用数学算法,进行高难度图像处理的一个例子。事实上,图像处理的数学算法,已经发展到令人叹为观止的地步。

Scriptol列出了几种神奇的图像处理算法,让我们一起来看一下。

一、像素图生成向量图的算法

数字时代早期的图片,分辨率很低。尤其是一些电子游戏的图片,放大后就是一个个像素方块。Depixelizing算法可以让低分辨率的像素图转化为高质量的向量图。

二、黑白图片的着色算法

让老照片自动变成彩色的算法

三、消除阴影的算法

不留痕迹地去掉照片上某件东西的阴影的算法

四、HDR照片的算法

  

 

 

 

所谓"HDR照片",就是扩大亮部与暗部的对比效果,亮的地方变得非常亮,暗的地方变得非常暗,亮暗部的细节都很明显。

实现HDR的软件有很多,这里推荐G'MIC。它是GIMP图像编辑软件的一个插件,代码全部开源。

五、消除杂物的算法

所谓"消除杂物",就是在照片上划出一块区域,然后用背景自动填补。Resynthesizer可以做到这一点,它也是GIMP的一个插件。

六、自动合成照片的算法

根据一张草图,选择原始照片,然后把它们合成在一起,生成新照片。这是清华大学的科研成果

七、美容算法

自动对容貌进行"美化"的算法

 

转载自:http://www.ruanyifeng.com/blog/2011/08/amazing_algorithms_of_image_processing.html

2018-08-26 14:27:54 fanyun_01 阅读数 910
  • Tensorflow-图像处理视频教程

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 课程以图像处理软件Tensorflow作为核心武器,基于图像处理热点话题进行案例实战。选择当下热门模型,使用真实数据集进行实战演示,通俗讲解整个算法模型并使用tensorflow进行实战,详解其中的原理与代码实现。

    1388 人正在学习 去看看 唐宇迪
/*函数名称:MakegGray()                                        */
/*函数类型:void                                               */
/*功能:真彩色转化成256色灰度图像。                            */
/***************************************************************/
void MakeColorDib::MakegGray()    //灰度变化
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();   //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 for(int j=0;j<height;j++) // 每行
  for(int i=0;i<DibWidth;i+=3) // 每列
  {
   BYTE* pbyBlue = p_data++;   //得到蓝色值
   BYTE* pbyGreen = p_data++;  //得到绿色值
   BYTE* pbyRed = p_data++;    //得到红色值
   BYTE r = *pbyRed;
   BYTE g = *pbyGreen;
   BYTE b = *pbyBlue;
   //取到原r,g,b中的最大值作为像素三分量值的新值
   int gray=0;
   if(r>g)
    gray=r;
   else 
    gray=g;
   if(gray<b)
    gray=b;   
         *pbyBlue = gray;     //将取到的最大值赋给像素的蓝分量
   *pbyGreen = gray;    //将取到的最大值赋给像素的绿分量
   *pbyRed = gray;      //将取到的最大值赋给像素的红分量
  }
}
 
/***************************************************************/
/*函数名称:LightAlter(int m_Light)                            */
/*函数类型:void                                               */
/*参数:int m_Light,用户给定的阈值                            */
/*功能:对图像使用阈值法进行亮度调整。                         */
/***************************************************************/
void MakeColorDib::LightAlter(int m_Light)    //亮度调整
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();    //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 for(int j=0;j<height;j++) // 每行
 for(int i=0;i<DibWidth;i++) // 每列
 {   
  int a=0;
  a=int(*p_data*m_Light/100);   //调整当前点的亮度
  *p_data=a;
  //判断范围,取得合理的值
  if(a<0) 
   *p_data=0;  
     if(a>255)
   *p_data=255;
        p_data++;   //指向下一指针
 }
}
 
/***************************************************************/
/*函数名称:LightReverse()                                     */
/*函数类型:void                                               */
/*功能:图像的亮度取反。                                       */
/***************************************************************/
void MakeColorDib::LightReverse()    //亮度取反
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 for(int j=0;j<height;j++) // 每行
  for(int i=0;i<DibWidth;i++) // 每列
  {
   int a=*p_data;   //取得当前点的值
   *p_data=255-a;    //取反
   p_data++;  //指向下一指针  
  }
}
 
/***************************************************************/
/*函数名称:ContrastAlter(int m_Increment)                     */
/*函数类型:void                                               */
/*参数:int m_Increment,用户给定的阈值                        */
/*功能:对图像使用阈值法调整对比度处理。                       */
/***************************************************************/
void MakeColorDib::ContrastAlter(int m_Increment)   ///对比度处理
{
 int nHigh = 255 - m_Increment;
 //对于极端情况加以处理
 if(nHigh < m_Increment)
 {
  nHigh = 127;
  m_Increment = 120;
 }
 if(m_Increment < -127)
  m_Increment = -120;
 //扩展或压缩区间的长度
 int nStretch = 255;
 if(m_Increment >= 0)
  nStretch = 255 - 2 * m_Increment;
 else
  nStretch = 255 + 2 * m_Increment;
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 if(m_Increment >= 0)   // m_Increment>=0时
 {
  for(int j=0;j<height;j++) // 每行
   for(int i=0;i<DibWidth-3;i+=3) // 每列
   {   
    //取得当前点(蓝色)的值,调整
    BYTE* pbyBlue = p_data++;    
    if(*pbyBlue<=m_Increment)
     *pbyBlue=0;
    else if(*pbyBlue>nHigh)
     *pbyBlue=255;
    else
     *pbyBlue=(BYTE)((((int)*pbyBlue - m_Increment) * 255) / nStretch );
    //取得当前点(绿色)的值,调整
    BYTE* pbyGreen = p_data++;
    if(*pbyGreen<=m_Increment)
     *pbyGreen=0;
    else if(*pbyGreen>nHigh)
     *pbyGreen=255;
    else
     *pbyGreen=(BYTE)((((int)*pbyGreen - m_Increment) * 255) / nStretch );
    //取得当前点(红色)的值,调整
    BYTE* pbyRed = p_data++;
    if(*pbyRed<=m_Increment)
     *pbyRed=0;
    else if(*pbyRed>nHigh)
     *pbyRed=255;
    else
     *pbyRed=(BYTE)((((int)*pbyRed - m_Increment) * 255) / nStretch );
   }
   
 }
 else  // m_Increment < 0 时
 {
  for(int j=0;j<height;j++)
   for(int i=0;i<DibWidth-3;i+=3)
   { //取得当前点(蓝色)的值,调整
    BYTE* pbyBlue = p_data++;
    *pbyBlue = (BYTE)((((int)(*pbyBlue) * nStretch) / 255) - m_Increment);
    //取得当前点(红色)的值,调整
    BYTE* pbyGreen = p_data++;
    *pbyGreen = (BYTE)((((int)(*pbyGreen) * nStretch) / 255) - m_Increment);
    //取得当前点(红色)的值,调整
    BYTE* pbyRed = p_data++;
    *pbyRed = (BYTE)((((int)(*pbyRed) * nStretch) / 255) - m_Increment);    
   }
 }
}
 
/***************************************************************/
/*函数名称:Exposal()                                          */
/*函数类型:void                                               */
/*功能:图像曝光处理。                                         */
/***************************************************************/
void MakeColorDib::Exposal() //曝光处理
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 for(int j=0;j<height;j++) // 每行
  for(int i=0;i<DibWidth;i++) // 每列
  {
   BYTE* pbydata = p_data++;  //取得当前点的值
   BYTE a=*pbydata;   //传给临时变量
   *pbydata=(a>128)?a:(255-a);   //调整
  }
  
}
 
/***************************************************************/
/*函数名称:PaintColor(int m_Red,int m_Green,int m_Blue)       */
/*函数类型:void                                               */
/*参数:int m_Red、m_Green、m_Blue,用户给定的红绿蓝值         */
/*功能:对图像使用阈值法进行着色处理。                         */
/***************************************************************/
void MakeColorDib::PaintColor(int m_Red,int m_Green,int m_Blue) //着色处理
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 for(int j=0;j<height;j++) // 每行
  for(int i=0;i<DibWidth;i+=3) // 每列
  {   
   BYTE* pbyBlue = p_data++; //取得当前点(蓝色)的值     
   BYTE* pbyGreen = p_data++;  //取得当前点(绿色)的值
   BYTE* pbyRed = p_data++;    //取得当前点(红色)的值
   BYTE r = *pbyRed;
   BYTE g = *pbyGreen;
   BYTE b = *pbyBlue;
      BYTE gray=(BYTE)(((WORD)r * 59 + (WORD)g * 30 + (WORD)b * 11) / 100);
   *pbyBlue = (BYTE)((m_Blue * gray) / 255);  
   *pbyGreen = (BYTE)((m_Green * gray) / 255);
   *pbyRed = (BYTE)((m_Red * gray) / 255);
  }
}
 
/***************************************************************/
/*函数名称:NeonLight()                                        */
/*函数类型:void                                               */
/*功能:使图像产生霓虹处理效果。                               */
/***************************************************************/
void MakeColorDib::NeonLight()   //霓虹处理
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
    BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存,以保存新图像
 for(int j=0;j<height-4;j++) // 每行
 {
  for(int i=0;i<DibWidth-1;i++) // 每列
  {
    int pby_pt=0;
    //对像素执行算法
    pby_pt=(*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j-1)*DibWidth+i+3))
       *(*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j-1)*DibWidth+i+3))
       +(*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j-2)*DibWidth+i))
       *(*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j-2)*DibWidth+i));
   *(p_temp+(height-j-1)*DibWidth+i)=2*int(sqrt(pby_pt));
   //判断合法性
   if(*(p_temp+(height-j-1)*DibWidth+i)<0)
     *(p_temp+(height-j-1)*DibWidth+i)=0;
   if(*(p_temp+(height-j-1)*DibWidth+i)>255)
     *(p_temp+(height-j-1)*DibWidth+i)=255;
  }
 }
    memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
    delete []p_temp;   //删除暂时分配内存
}
 
/***************************************************************/
/*函数名称:Smoothness()                                       */
/*函数类型:void                                               */
/*功能:使图像平滑处理。                                       */
/***************************************************************/
void MakeColorDib::Smoothness()   //平滑处理
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
    int h[3][3];////定义(3x3)矩阵
 h[0][0] = 1;  h[0][1] = 1; h[0][2] = 1;
 h[1][0] = 1;  h[1][1] = 1; h[1][2] = 1;
 h[2][0] = 1;  h[2][1] = 1; h[2][2] = 1;
    BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存,以保存新图像
 for(int j=0;j<height-2;j++) // 每行
 {
  for(int i=0;i<DibWidth-8;i++) // 每列
  {
         double pby_pt=0;
                    //对应的第0行的值乘以矩阵对应值,再相加
       pby_pt= h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))
        +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))
        +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6))
                    //对应的第1行的值乘以矩阵对应值,再相加
        +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))
        +h[1][1]*(*(p_data+(height-j-2)*DibWidth+i+3))
        +h[1][2]*(*(p_data+(height-j-2)*DibWidth+i+6))
                    //对应的第2行的值乘以矩阵对应值,再相加
              +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i))
     +h[2][1]*(*(p_data+(height-j-3)*DibWidth+i+3))
     +h[2][2]*(*(p_data+(height-j-3)*DibWidth+i+6));
   *(p_temp+(height-j-2)*DibWidth+i+3)=abs(int(pby_pt/9));//取总和的的平均值
  }
 }
    memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
    delete []p_temp;//删除暂时分配内存
}
 
/***************************************************************/
/*函数名称:Embossment()                                       */
/*函数类型:void                                               */
/*功能:产生图像浮雕处理效果。                                 */
/***************************************************************/
void MakeColorDib::Embossment()   //浮雕处理
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
    BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存,以保存新图像
 for(int j=0;j<height;j++) // 每行
 {
  for(int i=0;i<DibWidth-4;i++) // 每列
  {
    int pby_pt=0;
    //对像素得每个分量执行算法
    pby_pt=*(p_data+(height-j-1)*DibWidth+i)
       -*(p_data+(height-j-1)*DibWidth+i+3)+128;
    *(p_temp+(height-j-1)*DibWidth+i+3)=pby_pt;
   //检验合法性
   if(*(p_temp+(height-j-1)*DibWidth+i+3)<0)
    *(p_temp+(height-j-1)*DibWidth+i+3)=0;
   else if(*(p_temp+(height-j-1)*DibWidth+i+3)>255)
    *(p_temp+(height-j-1)*DibWidth+i+3)=255;
  }
 }
    memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
    delete []p_temp;   //删除暂时分配内存
}
 
/***************************************************************/
/*函数名称:Spread()                                           */
/*函数类型:void                                               */
/*功能:图像扩散处理。                                         */
/***************************************************************/
void MakeColorDib::Spread()   //扩散处理
{ 
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
    BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存,以保存新图像
 for(int j=0;j<height-4;j++) // 每行
 {
  for(int i=0;i<DibWidth-14;i++) // 每列
  {
    int m=0,n=0;
    m=rand()%5; //取得行随机数
    n=rand()%5; //取得列随机数
    int pby_pt=0; 
    pby_pt=*(p_data+(height-j-1-m)*DibWidth+i+3*n);//得到对应随机像素值
    *(p_temp+(height-j-3)*DibWidth+i+6)=pby_pt;
  }
 }
    memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
    delete []p_temp;   //删除暂时分配内存
}
 
/***************************************************************/
/*函数名称:Sharp()                                            */
/*函数类型:void                                               */
/*功能:图像锐化处理。                                         */
/***************************************************************/
void MakeColorDib::Sharp()   //图像锐化
{
  BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
    BYTE *p_temp=new BYTE[height*DibWidth];
 for(int j=0;j<height-1;j++) // 每行
 {
  for(int i=0;i<DibWidth-5;i++) // 每列
  {
         int pby_pt=0; 
   pby_pt= *(p_data+(height-j-2)*DibWidth+i+3)
          -*(p_data+(height-j-1)*DibWidth+i);
   *(p_temp+(height-j-2)*DibWidth+i+3)=*(p_data+(height-j-2)*DibWidth+i+3)
                                     +abs(int(pby_pt/4));
   if(*(p_temp+(height-j-2)*DibWidth+i+3)>255)
      *(p_temp+(height-j-2)*DibWidth+i+3)=255;
  }
 }
    memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
    delete []p_temp;  //删除暂时分配内存
}
 
/***************************************************************/
/*函数名称:HighLVBO(int m_GaoTong)                            */
/*函数类型:void                                               */
/*参数:int m_GaoTong,用户给定的阈值来选择矩阵                */
/*功能:对图像使用阈值法进行高通滤波。                         */
/***************************************************************/
void MakeColorDib::HighLVBO(int m_GaoTong)   //高通滤波
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 int h[3][3];  ////定义(3x3)矩阵
 if(m_GaoTong==1)
 {   //矩阵1(基本高通)
  h[0][0] =1;   h[0][1] =-2;  h[0][2] =1;
  h[1][0] =-2;  h[1][1] =5;   h[1][2] =-2;
  h[2][0] =1;   h[2][1] =-2;  h[2][2] =1;
 }
 else if(m_GaoTong==2)
 {   //矩阵2(中等高通)
  h[0][0] = 0;   h[0][1] = -1; h[0][2] = 0;
  h[1][0] = -1;  h[1][1] =  5; h[1][2] = -1;
  h[2][0] = 0;   h[2][1] = -1; h[2][2] = 0;
 }
 else
 {   //矩阵3(过量高通)
  h[0][0] = -1;  h[0][1] = -1; h[0][2] = -1;
  h[1][0] = -1;  h[1][1] =  9; h[1][2] = -1;
  h[2][0] = -1;  h[2][1] = -1; h[2][2] = -1;
 }
    BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存,以保存新图像
 for(int j=0;j<height-2;j++) // 每行
 {
  for(int i=0;i<DibWidth-8;i++) // 每列
  {
   int pby_pt=0;
   //对应的第0行的值乘以矩阵对应值,再相加
   pby_pt=  h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))
    +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))
    +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6))
    //对应的第1行的值乘以矩阵对应值,再相加
    +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))
    +h[1][1]*(*(p_data+(height-j-2)*DibWidth+i+3))
    +h[1][2]*(*(p_data+(height-j-2)*DibWidth+i+6))
    //对应的第2行的值乘以矩阵对应值,再相加
    +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i))
    +h[2][1]*(*(p_data+(height-j-3)*DibWidth+i+3))
    +h[2][2]*(*(p_data+(height-j-3)*DibWidth+i+6));
   *(p_temp+(height-j-2)*DibWidth+i+3)=abs(pby_pt);
   if(pby_pt>255) //判断是否越界
    *(p_temp+(height-j-2)*DibWidth+i+3)=255;
  }
 }
    memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
    delete []p_temp;  //删除暂时分配内存
}
 
/***************************************************************/
/*函数名称:LowLVBO()                                          */
/*函数类型:void                                               */
/*功能:实现图像低通滤波(3x3)。                                */
/***************************************************************/
void MakeColorDib::LowLVBO()   //低通滤波(3x3)
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
    double h[3][3];////定义(3x3)矩阵
 h[0][0] = 0.1;  h[0][1] = 0.1; h[0][2] = 0.1;
 h[1][0] = 0.1;  h[1][1] = 0.2; h[1][2] = 0.1;
 h[2][0] = 0.1;  h[2][1] = 0.1; h[2][2] = 0.1;
 BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存,以保存新图像
 for(int j=0;j<height-2;j++) // 每行
 {
  for(int i=0;i<DibWidth-8;i++) // 每列
  {
   double pby_pt=0;
            //对应的第0行的值乘以矩阵对应值,再相加 
   pby_pt=  h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))
    +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))
    +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6))
    //对应的第0行的值乘以矩阵对应值,再相加
    +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))
    +h[1][1]*(*(p_data+(height-j-2)*DibWidth+i+3))
    +h[1][2]*(*(p_data+(height-j-2)*DibWidth+i+6))
    //对应的第0行的值乘以矩阵对应值,再相加
    +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i))
    +h[2][1]*(*(p_data+(height-j-3)*DibWidth+i+3))
    +h[2][2]*(*(p_data+(height-j-3)*DibWidth+i+6));
   *(p_temp+(height-j-2)*DibWidth+i+3)=abs(int(pby_pt));
  }
 }
 memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
 delete []p_temp;  //删除暂时分配内存
}
 
/***************************************************************/
 
函数名称:LowVBObig()
 
函数类型:void
 
功能:实现函数低通滤波(5*5)
/***************************************************************/
void MakeColorDib::LowLVBObig()   //低通滤波(5x5)
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 int h[5][5];//定义(5x5)矩阵
 h[0][0] = 1;  h[0][1] = 1; h[0][2] = 1; h[0][3] = 1; h[0][4] = 1;
 h[1][0] = 1;  h[1][1] = 2; h[1][2] = 2; h[1][3] = 2; h[1][4] = 1;
 h[2][0] = 1;  h[2][1] = 2; h[2][2] = 3; h[2][3] = 2; h[2][4] = 1;
 h[3][0] = 1;  h[3][1] = 2; h[3][2] = 2; h[3][3] = 2; h[3][4] = 1;
 h[4][0] = 1;  h[4][1] = 1; h[4][2] = 1; h[4][3] = 1; h[4][4] = 1;
 BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存,以保存新图像
 for(int j=0;j<height-4;j++) // 每行
 {
  for(int i=0;i<DibWidth-14;i++) // 每列
  {
         int pby_pt=0;
         //对应的第0行的值乘以矩阵对应值,再相加
   pby_pt=h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))
      +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))
      +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6))
         +h[0][3]*(*(p_data+(height-j-1)*DibWidth+i+9))
      +h[0][4]*(*(p_data+(height-j-1)*DibWidth+i+12))
                  //对应的第1行的值乘以矩阵对应值,再相加
         +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))
         +h[1][1]*(*(p_data+(height-j-2)*DibWidth+i+3))
      +h[1][2]*(*(p_data+(height-j-2)*DibWidth+i+6))
      +h[1][3]*(*(p_data+(height-j-2)*DibWidth+i+9))
      +h[1][4]*(*(p_data+(height-j-2)*DibWidth+i+12))
                  //对应的第2行的值乘以矩阵对应值,再相加
         +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i))
      +h[2][1]*(*(p_data+(height-j-3)*DibWidth+i+3))
      +h[2][2]*(*(p_data+(height-j-3)*DibWidth+i+6))
      +h[2][3]*(*(p_data+(height-j-3)*DibWidth+i+9))
      +h[2][4]*(*(p_data+(height-j-3)*DibWidth+i+12))
                  //对应的第3行的值乘以矩阵对应值,再相加
         +h[3][0]*(*(p_data+(height-j-4)*DibWidth+i))
         +h[3][1]*(*(p_data+(height-j-4)*DibWidth+i+3))
      +h[3][2]*(*(p_data+(height-j-4)*DibWidth+i+6))
      +h[3][3]*(*(p_data+(height-j-4)*DibWidth+i+9))
      +h[3][4]*(*(p_data+(height-j-4)*DibWidth+i+12))
                  //对应的第4行的值乘以矩阵对应值,再相加
         +h[4][0]*(*(p_data+(height-j-5)*DibWidth+i))
      +h[4][1]*(*(p_data+(height-j-5)*DibWidth+i+3))
      +h[4][2]*(*(p_data+(height-j-5)*DibWidth+i+6))
      +h[4][3]*(*(p_data+(height-j-5)*DibWidth+i+9))
      +h[4][4]*(*(p_data+(height-j-5)*DibWidth+i+12));
                  //为了计算方便我们把除以35(矩阵权和)放在求总和之后
   *(p_temp+(height-j-3)*DibWidth+i+6)=abs(int(pby_pt/35));
  }
 }
 memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
 delete []p_temp;  //删除暂时分配内存
}
 
/***************************************************************/
/*函数名称:ShuiPingGROW()                                     */
/*函数类型:void                                               */
/*功能:使图像水平增强。                                       */
/***************************************************************/
void MakeColorDib::ShuiPingGROW()   //水平增强
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 int h[3][1];//定义(3x1)矩阵
 h[0][0] = -1;  
 h[1][0] = 2; 
 h[2][0] = -1;
 BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存,以保存新图像
 for(int j=0;j<height-2;j++) // 每行
 {
  for(int i=0;i<DibWidth-8;i++) // 每列
  {
   int pby_pt=0;
   //对应的3行的值乘分别以矩阵对应值,再相加
   pby_pt= h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))
    +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))
    +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i));
   if(pby_pt>20)
    *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt)+100;
   else
    *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt);
  }
 }
 memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
    delete []p_temp;  //删除暂时分配内存
}
 
/***************************************************************/
/*函数名称:ChuiZhiGROW()                                      */
/*函数类型:void                                               */
/*功能:使图像垂直增强。                                       */
/***************************************************************/
void MakeColorDib::ChuiZhiGROW()   //垂直增强
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 int h[1][3];//定义(1x3)矩阵
 h[0][0] = -1; 
 h[0][1] = 2;
 h[0][2] = -1;
 BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存,以保存新图像
 for(int j=0;j<height-2;j++) // 每行
 {
  for(int i=0;i<DibWidth-8;i++) // 每列
  {
   int pby_pt=0;
   //对应的第0行的值乘以矩阵对应值,再相加
   pby_pt= h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))
    +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))
    +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6));
   if(pby_pt>20)
    *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt)+100;
   else
    *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt);
  }
 }
 memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
 delete []p_temp;  //删除暂时分配内存
}
 
/***************************************************************/
/*函数名称:ShuangXiangGROW()                                  */
/*函数类型:void                                               */
/*功能:使图像双向增强。                                       */
/***************************************************************/
void MakeColorDib::ShuangXiangGROW()    //双向增强
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 int h[3][3];//定义(3x3)矩阵
 h[0][0] = -1;  h[0][1] = -1; h[0][2] = -1;
 h[1][0] = -1;  h[1][1] =  8; h[1][2] = -1;
 h[2][0] = -1;  h[2][1] = -1; h[2][2] = -1; 
 BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存,以保存新图像
 for(int j=0;j<height-2;j++) // 每行
 { 
  for(int i=0;i<DibWidth-8;i++) // 每列
  {
   int pby_pt=0;
   //对应的第0行的值乘以矩阵对应值,再相加
   pby_pt= h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))
    +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))
    +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6))
    //对应的第1行的值乘以矩阵对应值,再相加
    +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))
    +h[1][1]*(*(p_data+(height-j-2)*DibWidth+i+3))
    +h[1][2]*(*(p_data+(height-j-2)*DibWidth+i+6))
    //对应的第2行的值乘以矩阵对应值,再相加
    +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i))
    +h[2][1]*(*(p_data+(height-j-3)*DibWidth+i+3))
    +h[2][2]*(*(p_data+(height-j-3)*DibWidth+i+6));
   if(pby_pt>20)
    *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt)+100;
   else
    *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt);
  }
 } 
 memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
 delete []p_temp;  //删除暂时分配内存
}
 
/***************************************************************/
/*函数名称:Mosaic()                                           */
/*函数类型:void                                               */
/*功能:使图像产生马赛克效果。                                 */
/***************************************************************/
void MakeColorDib::Mosaic()    //马赛克
{
 BYTE *p_data;     //原图数据区指针
 int wide,height,DibWidth;    //原图长、宽、字节宽
 p_data=this->GetData ();   //取得原图的数据区指针
    wide=this->GetWidth ();  //取得原图的数据区宽度
    height=this->GetHeight ();   //取得原图的数据区高度
 DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
 BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存,以保存新图像
 for(int j=0;j<height-4;j+=5) // 每行
 { 
     for(int i=0;i<DibWidth-14;i+=15) // 每列
  {   //对应周围(5x5)矩阵蓝色值求和平均
   int pby_pt=0;
   for(int m=0;m<5;m++)
    for(int n=0;n<15;n+=3)
    {   
     pby_pt+=*(p_data+(height-j-1-m)*DibWidth+i+n);
    }
    
   for(m=0;m<5;m++)
    for(int n=0;n<14;n+=3)
    {
     *(p_temp+(height-j-1-m)*DibWidth+i+n)=int(pby_pt/25);
    } 
            //对应周围(5x5)矩阵绿色值求和平均
   pby_pt=0;
   for(m=0;m<5;m++)
    for(int n=0;n<15;n+=3)
    {
     pby_pt+=*(p_data+(height-j-1-m)*DibWidth+i+n+1);
    }
   for(m=0;m<5;m++)
    for(int n=0;n<14;n+=3)
    {
     *(p_temp+(height-j-1-m)*DibWidth+i+n+1)=int(pby_pt/25);
    }
            //对应周围(5x5)矩阵红色值求和平均
   pby_pt=0;
   for(m=0;m<5;m++)
    for(int n=0;n<15;n+=3)
    {
     pby_pt+=*(p_data+(height-j-1-m)*DibWidth+i+n+2);
    }
   for(m=0;m<5;m++)
    for(int n=0;n<14;n+=3)
    {
     *(p_temp+(height-j-1-m)*DibWidth+i+n+2)=int(pby_pt/25);
    }
  }   
 }
 memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
 delete []p_temp;  //删除暂时分配内存
}
 
 
 
 

 

2018-08-26 14:27:40 fanyun_01 阅读数 5365
  • Tensorflow-图像处理视频教程

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 课程以图像处理软件Tensorflow作为核心武器,基于图像处理热点话题进行案例实战。选择当下热门模型,使用真实数据集进行实战演示,通俗讲解整个算法模型并使用tensorflow进行实战,详解其中的原理与代码实现。

    1388 人正在学习 去看看 唐宇迪

图像处理算法1总结如下:

//添加椒盐噪声
void salt(Mat& src,int number)
{
	for (int i = 0; i < number; i++)
	{
		int r = static_cast<int>(rng.uniform(0, src.rows));
		int c = static_cast<int>(rng.uniform(0, src.cols));
		int k = (static_cast<int>(rng.uniform(0, 1000))&1);
		if(k==1)
		    src.at<uchar>(r, c) = 255;
		else
			src.at<uchar>(r, c) = 0;
	}
	return;
}
/*
* @ drt :高斯方差
* @ Medium :高斯均值
*/
int Get_Gauss(int Medium, int drt)
{
	//产生高斯样本,以U为均值,D为均方差
	double sum = 0;
	for (int i = 0; i<12; i++) sum += rand() / 32767.00;
	//计算机中rand()函数为-32767~+32767(2^15-1)
	//故sum+为0~1之间的均匀随机变量
	return int(Medium + drt*(sum - 6));
	//产生均值为U,标准差为D的高斯分布的样本,并返回
}
/*
* variance :高斯噪声的方差
*/
 
//添加高斯噪声
void ImgAddGaussNoise1(const uchar *srcimgbuff, uchar * dstImgbuff, int srcwith, int srcheigh, int chanels)
{
	assert(srcimgbuff != NULL && srcwith > 0 && srcheigh > 0);
	int bytecount = srcwith * srcheigh * chanels;
 
	for (size_t i = 0; i < bytecount; i++)
	{
		dstImgbuff[i] += Get_Gauss(20, 0.02);
	}
}
//中值求取
void Media(Mat* src, int indexrows, int indexcols, int* meanv, int ker)
{
	int lo = (ker - 1) / 2;
	vector<int>moreo;
	for (int i = indexrows - lo; i <= indexrows + lo; i++)
	{
		for (int j = indexcols - lo; j <= indexcols + lo; j++)
		{
			moreo.push_back(src->at<uchar>(i, j));
		}
	}
	sort(moreo.begin(), moreo.end());
	*meanv = moreo.at(ker * ker / 2);
	return;
}
//均值求取
void Meanvalue(Mat* src, int indexrows, int indexcols, float* meanv, int ker)
{
	int lo = (ker - 1) / 2;
	float total = 0;
	for (int i = indexrows - lo; i <= indexrows + lo; i++)
	{
		for (int j = indexcols - lo; j <= indexcols + lo; j++)
		{
			total += src->at<uchar>(i, j);
		}
	}
	*meanv = total / (ker * ker);
	return;
}
//像素方差
void Variance(Mat& src, vector<test>& hierachy, int ker)
{
	int row = src.rows;
	int col = src.cols;
	int lo = (ker - 1) / 2;
	for (int ir = lo; ir < row - lo; ir++)
	{
		for (int jc = lo; jc < col - lo; jc++)
		{
			float means;
			int var;
			//计算均值
			Meanvalue(&src, ir, jc, &means, ker);
			Vvalue(&src, ir, jc, &var, ker, means);
			test temp;
			temp.menval = var;
			temp.x = ir;
			temp.y = jc;
			hierachy.push_back(temp);
		}
	}
	return;
}
//局部方差求取
void Vvalue(Mat* src, int indexrows, int indexcols, int* vall, int ker, float mean)
{
	int lo = (ker - 1) / 2;
	float total = 0;
	for (int i = indexrows - lo; i <= indexrows + lo; i++)
	{
		for (int j = indexcols - lo; j <= indexcols + lo; j++)
		{
			total += pow((src->at<uchar>(i, j) - mean), 2);
		}
	}
	*vall = static_cast<int>(total);
	return;
}
//STL排序方式
bool SortByM1(const test &v1, const test &v2)//注意:本函数的参数的类型一定要与vector中元素的类型一致  
{
	return v1.menval < v2.menval;//升序排列  
}
//SSIM 结构相似比
Scalar getMSSIM(const Mat& i1, const Mat& i2)
{
	const double C1 = 6.5025, C2 = 58.5225;
	/***************************** INITS **********************************/
	int d = CV_32F;
 
	Mat I1, I2;
	i1.convertTo(I1, d);           // cannot calculate on one byte large values
	i2.convertTo(I2, d);
 
	int num = I1.channels();
	//cv::imshow("123", I1);
	//cv::waitKey();
 
	Mat I2_2 = I2.mul(I2);        // I2^2
	Mat I1_2 = I1.mul(I1);        // I1^2
	Mat I1_I2 = I1.mul(I2);        // I1 * I2
 
								   /*************************** END INITS **********************************/
 
	Mat mu1, mu2;   // PRELIMINARY COMPUTING
	GaussianBlur(I1, mu1, Size(11, 11), 1.5);
	GaussianBlur(I2, mu2, Size(11, 11), 1.5);
 
	Mat mu1_2 = mu1.mul(mu1);
	Mat mu2_2 = mu2.mul(mu2);
	Mat mu1_mu2 = mu1.mul(mu2);
 
	Mat sigma1_2, sigma2_2, sigma12;
 
	GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);
	sigma1_2 -= mu1_2;
 
	GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);
	sigma2_2 -= mu2_2;
 
	GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);
	sigma12 -= mu1_mu2;
 
	///////////////////////////////// FORMULA ////////////////////////////////
	Mat t1, t2, t3;
 
	t1 = 2 * mu1_mu2 + C1;
	t2 = 2 * sigma12 + C2;
	t3 = t1.mul(t2);              // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
 
	t1 = mu1_2 + mu2_2 + C1;
	t2 = sigma1_2 + sigma2_2 + C2;
	t1 = t1.mul(t2);               // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
 
	Mat ssim_map;
	divide(t3, t1, ssim_map);      // ssim_map =  t3./t1;
 
	Scalar mssim = mean(ssim_map); // mssim = average of ssim map
	return mssim;
}

 

没有更多推荐了,返回首页