图像处理的几种常用方法_常见的图像分割方法有以下几种 - CSDN
  • 深度学习模型训练时通常都需要大量的训练集,我们在做图像相关的应用时同样需要进行图像数据增加,下面我将给大家总结10种图像数据增强常用的方式 1、水平翻转 随机的对图片进行水平翻转,这个参数适用于水平翻转...

    深度学习模型训练时通常都需要大量的训练集,我们在做图像相关的应用时同样需要进行图像数据增加,下面我将给大家总结10种图像数据增强常用的方式

    1、水平翻转
    随机的对图片进行水平翻转,这个参数适用于水平翻转不影响图片语义的时候。

    2、竖直翻转
    随机的对图片进行竖直翻转,这个参数适用于竖直翻转不影响图片语义的时候。

    3、随机翻转角度
    设置一个0~180的度数,用来指定随机旋转图片的角度。

    4、随机水平平移
    用来指定水平方向随机移动的程度。

    5、随机竖直平移
    用来指定竖直方向随机移动的程度。

    6、随机错切变换
    在某方向上,按照一定的比例对图形的每个点到某条平行于该方向的直线的有向距离做放缩得到的平面图形。

    7、随机放大
    对图片进行随机的放大。

    8、颜色抖动
    改变图片的颜色,通过对颜色通道的数值偏移,改变图片的整体的颜色。

    9、rescale
    rescale的作用是对图片的每个像素值均乘上这个放缩因子,这个操作在所有其它变换操作之前执行,在一些模型当中,直接输入原图的像素值可能会落入激活函数的饱和区,因此设置放缩因子为1/255,把像素值放缩到0和1之间有利于模型的收敛,避免神经元饱和。图片经过rescale之后,保存到本地的图片用肉眼看是没有任何区别的。

    10、fill_mode
    fill_mode为填充模式,如前面提到,当对图片进行平移、放缩、错切等操作时,图片中会出现一些缺失的地方,就由fill_mode中的参数确定。包括:“constant”、“nearest”(默认)、“reflect”和“wrap”。

    通常来说我们不会只使用单一的数据增加方法,而是会多种方式结合使用

    以上只是常用的几种图像数据增强方法,还有更好的其他方法,请结合自身项目。

    引用:
    https://mp.weixin.qq.com/s?__biz=MzUxOTgxMjkwNA==&mid=2247485619&idx=1&sn=d3a30397462861bf8b01c2570e9b8388&chksm=f9f2aaf4ce8523e25b7691bdb2e2e0526580f4c14ca307089017f21a3ff82232857039ac319d&mpshare=1&scene=1&srcid=11238ugMfOHeYBHXLTfT0llT&key=fe048f5ad4fa1bcf827d20099e0f30a24b151eaee46d0b492d027be2f0e420506744d70e6e8e97982b4cf9efdde30378cf048d45208189d545c91723f9cd1bd9a8a48a13e0a20c1a5bf72644e2bb575c&ascene=1&uin=MjE3OTYwMjg2Mw%3D%3D&devicetype=Windows+10&version=62060833&lang=zh_CN&pass_ticket=apm0Olp6oFmGwJatwtCpRNrEa36m9QcJSdkodK2aDwPRHUFGGRA79xznbiIxDOjZ

    展开全文
  • 几种常见图像处理方法

    千次阅读 2012-12-10 10:21:40
    ====================================...本章所涉及的方法有:灰度化彩色图像,将图像转换为ASNII码文件,直方图均衡化,伽马校正,哈尔小波变换。 0.知识储备 这里我们处理的是bmp格式的图像,bmp格式的文件有

    转自:http://blog.csdn.net/smells2/article/details/7378840

    =============================================

    本章所涉及的方法有:灰度化彩色图像,将图像转换为ASNII码文件,直方图均衡化,伽马校正,哈尔小波变换。

    0.知识储备

    这里我们处理的是bmp格式的图像,bmp格式的文件有3个文件头,第一个文件头大小为14个字节,主要是对整个文件的信息的存储。

    1. typedef struct tagBITMAPFILEHEADER {  
    2.         WORD    bfType;  
    3.         DWORD   bfSize;  
    4.         WORD    bfReserved1;  
    5.         WORD    bfReserved2;  
    6.         DWORD   bfOffBits;  
    7. } BITMAPFILEHEADER, FAR *LPBITMAPFILEHEADER, *PBITMAPFILEHEADER;  

    第二个文件头大小为50个字节,主要存储了图像的信息,比如,图像有多少行,多少列,大小等等。

    1. typedef struct tagBITMAPINFOHEADER{  
    2.         DWORD      biSize;  
    3.         LONG       biWidth;  
    4.         LONG       biHeight;  
    5.         WORD       biPlanes;  
    6.         WORD       biBitCount;  
    7.         DWORD      biCompression;  
    8.         DWORD      biSizeImage;  
    9.         LONG       biXPelsPerMeter;  
    10.         LONG       biYPelsPerMeter;  
    11.         DWORD      biClrUsed;  
    12.         DWORD      biClrImportant;  
    13. } BITMAPINFOHEADER, FAR *LPBITMAPINFOHEADER, *PBITMAPINFOHEADER;  

    第三个文件头,是图像的调色板,这里我们使用的文件是24位真彩,所以没有调色板,这个文件头不存在,所以我就不列在下面了。

    注意:bmp格式图像数据是倒着存贮的,具体可以参考百度百科http://baike.baidu.com/view/7671.htm#2


    1.将彩色图像转换为灰度图像

    我们都知道,图像是一像素为单位的,一个像素有三个色彩分量组成,即RGB(红绿蓝),每一个分量由8位(一个字节)组成,范围是0-255 。灰度图像可由彩色图像转化,可以使用公式gray = 0.3*red+0.59*green+0.11*blue,并且三个分量的值相等,即red = gray,green=gray,blue=gray。那么,我们的图像就变成了灰度图像。

    1. /******************************************** 
    2.  *     将文件转换成灰度图像           * 
    3.  ********************************************/  
    4. int CBitMapFile::turn2Gray()  
    5. {  
    6.     if (m_imageArray == NULL)  
    7.     {  
    8.         return -2;  
    9.     }  
    10.       
    11.     for (int i =0,j= 0,k=0;i<m_sizeImage;)  
    12.     {  
    13.         //转换为灰度图像,注意填充的字节  
    14.         BYTE blue,green,red,gray;  
    15.   
    16.         blue = m_imageArray[i];  
    17.         green = m_imageArray[i+1];  
    18.         red = m_imageArray[i+2];  
    19.           
    20.         m_realColorImageArray[k] = blue;  
    21.         m_realColorImageArray[k+1] = green;  
    22.         m_realColorImageArray[k+2] = red;  
    23.   
    24.         gray = (BYTE)(0.3*red+0.59*green+0.11*blue);  
    25.   
    26.         m_imageArray[i] = gray;  
    27.         m_imageArray[i+1] = gray;  
    28.         m_imageArray[i+2] = gray;  
    29.   
    30.         m_realImageArray[j] = m_imageArray[i];  
    31.   
    32.         i += 3;  
    33.         k += 3;  
    34.         j++;  
    35.   
    36.         跳过填充字节  
    37.         if (j % m_width == 0)  
    38.         {  
    39.             i += m_addByte;  
    40.         }  
    41.           
    42.     }  
    43.       
    44.     return 1;  
    45. }  


    2.图像转换为ASNII码文件

    三个步骤:(1)提取图像数据(2)建立映射表(3)处理灰度并映射

    映射表我建立的是8个字符'@','$','#','%','!','~','^','`'

    把灰度值除上32将其范围映射到0-7这个范围内。

    将灰度值按照映射表映射。

    1. /****************************************** 
    2.  *对图像的每个像素做文本映射,最终写入文件* 
    3.  ******************************************/  
    4. int CBitMapFile::turn2Txt(CFile& txtFile)  
    5. {  
    6.     char* _txtBuf = new char[m_width*m_height+2*m_height];  
    7.     memset(_txtBuf,0,m_width*m_height+2*m_height);  
    8.   
    9.     //文本映射  
    10.     char txtMap[8] = {'@','$','#','%','!','~','^','`'};  
    11.   
    12.     char* _buf = new char[m_width+2];  
    13.     memset(_buf,0,m_width+2);  
    14.     //TRACE(_T("\'\\r\'=%x,\'\\n\'=%x"),'\r','\n');  
    15.     for (int i = m_height-1;i>=0;i--)  
    16.     {  
    17.         for (int j = 0;j<m_width;j++)  
    18.         {  
    19.             _buf[j] = txtMap[m_realImageArray[i*m_width+j]>>5];  
    20.               
    21.         }  
    22.           
    23.         _buf[m_width] = '\r';  
    24.         _buf[m_width+1] = '\n';  
    25.           
    26.         for (int k=0;k<m_width+2;k++)  
    27.         {  
    28.             _txtBuf[(m_height-1-i)*m_width+k+(m_height-1-i)*2] = _buf[k];  
    29.           
    30.         }  
    31.     }  
    32.       
    33.     txtFile.Write(_txtBuf,sizeof(char)*(m_width*m_height+2*m_height));  
    34.   
    35.     delete _txtBuf;  
    36.     delete _buf;  
    37.     return 1;  
    38. }  

    3.直方图均衡化

    每一幅图像都有自己的直方图


    图像取自冈萨雷斯的《数字图像处理》第三版

    这幅图像的灰度大部分集中在较高的灰度,均衡化就使图像在概率率较大的地方稀疏一点,概率较小的地方稠密一点。

    方法是:(1)统计各个灰度的概率(2)归一化(3)画直方图(4)累计概率(5)取整得到映射(6)将原灰度值映射到新灰度值

    1. /******************************************** 
    2.  *  对bmp文件的每个像素的灰度值进行统计     * 
    3.  ********************************************/  
    4. int CBitMapFile::addupLevel()  
    5. {  
    6.     for (int i = 0;i<m_width*m_height;i++)  
    7.     {  
    8.         m_grayStatistic[m_realImageArray[i]] += 1;  
    9.           
    10.     }  
    11.     for (int i = 0;i<256;i++)  
    12.     {  
    13.         if (m_grayStatistic[i]>m_max)  
    14.         {  
    15.             m_max = m_grayStatistic[i];  
    16.         }  
    17.       
    18.     }  
    19.     //TRACE(_T("m_max = %d\n"),m_max);  
    20.     return 1;  
    21. }  
    22. /******************************************** 
    23.  *  对bmp文件的每个像素的灰度值进行归一化    * 
    24.  *      并计算每个像素灰度值的概率           * 
    25.  ********************************************/  
    26. int CBitMapFile::turn2One()  
    27. {  
    28.     for (int i =0;i<256;i++)  
    29.     {  
    30.         m_grayTurn2OneData[i] = (double)m_grayStatistic[i]/m_max;  
    31.         m_grayFrequencyPerLevel[i] = (double)m_grayStatistic[i]/(m_width*m_height);  
    32.       
    33.     }  
    34.     m_maxFrequency = m_max/(m_width*m_height);  
    35.     return 1;  
    36. }  
    37.   
    38. /******************************************** 
    39.  *  清除统计数组、归一化数组、频率数组       * 
    40.  ********************************************/  
    41. void CBitMapFile::clearup()  
    42. {  
    43.     memset(m_grayStatistic,0,sizeof(LONG)*256);  
    44.     memset(m_grayTurn2OneData,0,sizeof(double)*256);  
    45.     memset(m_grayFrequencyPerLevel,0,sizeof(double)*256);  
    46.     m_max = 0;  
    47.     m_maxFrequency = 0.0f;  
    48. }  
    49. /******************************************** 
    50.  *              灰度均衡化                   * 
    51.  ********************************************/  
    52. void CBitMapFile::equation(CFile& file)  
    53. {  
    54.     double _temp =0.0f;  
    55.     double* _array = new double[256];  
    56.     memset(_array,0,sizeof(double)*256);  
    57.     int* _intArray = new int[256];  
    58.     memset(_intArray,0,sizeof(int)*256);  
    59.     BYTE* _writeArray = new BYTE[m_sizeImage];  
    60.     memset(_writeArray,0,sizeof(BYTE)*m_sizeImage);  
    61.     for(int i = 0;i<256;i++)  
    62.     {  
    63.         _array[i] = ((m_grayFrequencyPerLevel[i])*255)+_temp;  
    64.         _temp = _array[i];  
    65.           
    66.     }  
    67.     for (int i = 0;i<256;i++)  
    68.     {  
    69.         _intArray[i] = (int)(_array[i]);  
    70.     }  
    71.     for (int i = 0,j = 0;i<m_sizeImage;)  
    72.     {  
    73.           
    74.         _writeArray[i] = _intArray[m_realImageArray[j]];  
    75.         _writeArray[i+1] = _intArray[m_realImageArray[j]];  
    76.         _writeArray[i+2] = _intArray[m_realImageArray[j]];  
    77.         j++;  
    78.         i += 3;  
    79.         if (j%m_width == 0)  
    80.         {  
    81.             for (int k = 0;k<m_addByte;k++)  
    82.             {  
    83.                 _writeArray[i+k] = 0;  
    84.                   
    85.             }  
    86.             i += m_addByte;  
    87.         }  
    88.     }  
    89.     file.Write(&m_file_header,sizeof(BITMAPFILEHEADER));  
    90.     file.Write(&m_info_header,sizeof(BITMAPINFOHEADER));  
    91.     file.Write(_writeArray,sizeof(BYTE)*m_sizeImage);  
    92.     delete _array;  
    93.     delete _intArray;  
    94.     delete _writeArray;  
    95. }  


    4.伽马校正

    伽马校正其实很简单,就是将旧的灰度值通过一个由灰度值为底,伽马次幂的映射得到新的灰度值,它的做用是,对于不同的伽马系数的选取,会使得某些较亮的图片,变得对比度适当。

    1. /******************************************** 
    2.  *              伽马校正                    * 
    3.  ********************************************/  
    4. void CBitMapFile::gammaCorrection(double gamma,CFile& file)  
    5. {  
    6.     //数据准备  
    7.     double* _correctData = new double[m_width*m_height];  
    8.     BYTE* _writeArray = new BYTE[m_sizeImage];  
    9.     memset(_writeArray,0,sizeof(BYTE)*m_sizeImage);  
    10.     memset(_correctData,0,sizeof(double)*m_width*m_height);  
    11.     //算法  
    12.     for (int i = 0;i<m_width*m_height;i++)  
    13.     {  
    14.         _correctData[i] = (double)m_realImageArray[i]/255;  
    15.       
    16.         _correctData[i] = pow(_correctData[i],gamma)*255;  
    17.   
    18.     }  
    19.     //写入文件准备  
    20.     for (int i = 0,j = 0;i<m_sizeImage;)  
    21.     {  
    22.         _writeArray[i] = (BYTE)_correctData[j];  
    23.         _writeArray[i+1] = (BYTE)_correctData[j];  
    24.         _writeArray[i+2] = (BYTE)_correctData[j];  
    25.         j++;  
    26.         i += 3;  
    27.         if (j%m_width == 0)  
    28.         {  
    29.             for (int k = 0;k<m_addByte;k++)  
    30.             {  
    31.                 _writeArray[i+k] = 0;  
    32.                   
    33.             }  
    34.             i += m_addByte;  
    35.         }  
    36.     }  
    37.     //写入文件  
    38.     file.Write(&m_file_header,sizeof(BITMAPFILEHEADER));  
    39.     file.Write(&m_info_header,sizeof(BITMAPINFOHEADER));  
    40.     file.Write(_writeArray,sizeof(BYTE)*m_sizeImage);  
    41.       
    42.     delete _writeArray;  
    43.     delete _correctData;  
    44. }  


    这个是伽马选择7.5的效果

    4.哈尔小波变换(HWT,haar wavelet tansform)

    这个是小波变换里最简单的一个,由于涉及较多的数学,这里就不做赘述了,只是附上程序。(程序使用的矩阵乘法是我自己写的,效率较低,经过测试在128*128的大小的图像效果可以,再大就会出现未响应的现象。)

    注意,哈尔小波变换的矩阵是偶数*偶数的,所以图片的行列也必须是偶数。

    Matrix.h

    1. #pragma once  
    2. #define ZERO 0  //零阵  
    3. #define IDENTITY 1//单位阵  
    4. #define HAAR 2//HAAR小波矩阵  
    5. #define UNSQUARE -1//非方阵  
    6. #define UNSAME -2//非同型矩阵  
    7. #define UNSAME -2//非同型矩阵  
    8. #define UNEVEN -3//行列非偶数  
    9.   
    10. class CMatrix  
    11. {  
    12. public:  
    13.     CMatrix(int r,int c);  
    14.     CMatrix(CMatrix& m);  
    15.     CMatrix(double* d,int r,int c);  
    16.     CMatrix(BYTE* d,int r,int c);  
    17.     ~CMatrix();  
    18.     int inital(int type);//初始化为单位阵,或特殊矩阵(以后扩展)  
    19. #ifdef _DEBUG  
    20.     void display();  
    21. #endif  
    22.     //  
    23. public:  
    24.     CMatrix& transpose();//矩阵的转置  
    25.     void nonZero();  
    26.     //  
    27. public:  
    28.      CMatrix& operator=(CMatrix& m1);  
    29.      friend CMatrix operator+(CMatrix& m1,CMatrix& m2);  
    30.      friend CMatrix operator-(CMatrix& m1,CMatrix& m2);  
    31.      friend CMatrix operator*(CMatrix& m1,double& a);  
    32.      friend CMatrix operator*(CMatrix& m1,CMatrix& m2);  
    33.     //  
    34. public:  
    35.     inline int getRow(){return m_row;}  
    36.     inline int getCol(){return m_col;}  
    37.     //inline CString getName(){return m_name;}  
    38.     inline double getElem(int r,int c){return m_data[r*m_row+c];}  
    39.     inline double* getData(){return m_data;}  
    40.     //  
    41. protected:  
    42.     int m_row;  
    43.     int m_col;  
    44.     double* m_data;  
    45. //  CString m_name;  
    46. };  


    Matrix.cpp

    1. #include "StdAfx.h"  
    2.   
    3. #include "MatrixBase.h"  
    4. #ifdef _DEBUG  
    5. #include <iostream>  
    6. #endif  
    7.   
    8. CMatrix::CMatrix(int r,int c)  
    9. {  
    10.     m_row = r;  
    11.     m_col = c;  
    12.     m_data = new double[r*c];  
    13.     memset(m_data,0,sizeof(double)*r*c);  
    14. }  
    15. CMatrix::CMatrix(double* d,int r,int c)  
    16. {  
    17.     m_row = r;  
    18.     m_col = c;  
    19.     m_data = new double[r*c];  
    20.     for (int i = 0;i<r*c;i++)  
    21.     {  
    22.         m_data[i] = d[i];  
    23.     }  
    24. }  
    25. CMatrix::CMatrix(BYTE* d,int r,int c)  
    26. {  
    27.     m_row = r;  
    28.     m_col = c;  
    29.     m_data = new double[r*c];  
    30.     for (int i = 0;i<r*c;i++)  
    31.     {  
    32.         m_data[i] = (double)d[i];  
    33.     }  
    34. }  
    35. CMatrix::CMatrix(CMatrix& m)  
    36. {  
    37.     this->m_row = m.m_row;  
    38.     this->m_col = m.m_col;  
    39.     m_data = new double[m_row*m_col];  
    40.     for (int i = 0;i<m_row*m_col;i++)  
    41.     {  
    42.         this->m_data[i] = m.m_data[i];  
    43.         TRACE(_T("data[%d]=%f\n"),i,this->m_data[i]);  
    44.     }  
    45. }  
    46. CMatrix::~CMatrix()  
    47. {  
    48.     delete[] m_data;  
    49. }  
    50. int CMatrix::inital(int type)  
    51. {  
    52.       
    53.     switch(type)  
    54.     {  
    55.     case IDENTITY:  
    56.         if (m_row != m_col)  
    57.         {  
    58.             return UNSQUARE;  
    59.         }  
    60.         for (int i=0;i<m_col;i++)  
    61.         {  
    62.             m_data[i*m_row+i] = 1;  
    63.         }  
    64.         break;  
    65.     case HAAR:  
    66.         if (m_row != m_col)  
    67.         {  
    68.             return UNSQUARE;  
    69.         }  
    70.         if (m_row%2 != 0)  
    71.         {  
    72.             return UNEVEN;  
    73.         }  
    74.         for(int i = 0;i<m_row/2;i++)  
    75.         {  
    76.             m_data[i*m_row+i*2] = 1;  
    77.             m_data[i*m_row+i*2+1] = 1;  
    78.         }  
    79.         for (int i = m_row/2,j = 0;i<m_row;i++,j++)  
    80.         {  
    81.             m_data[i*m_row+j*2] = -1;  
    82.             m_data[i*m_row+j*2+1] = 1;  
    83.         }  
    84.         break;  
    85.     default:  
    86.         break;  
    87.     }  
    88.     return type;  
    89. }  
    90. CMatrix& CMatrix::operator=(CMatrix& m1)  
    91. {  
    92.     ASSERT(m_row == m1.getRow() && m_col == m1.getCol());  
    93.     for (int i = 0;i<m_row*m_col;i++)  
    94.     {  
    95.         m_data[i] = m1.getElem(i/m_row,i%m_row);  
    96.         TRACE(_T("\'=\'data[%d]=%f\n"),i,m_data[i]);  
    97.     }  
    98.     return *this;  
    99. }  
    100. CMatrix operator+(CMatrix& m1,CMatrix& m2)  
    101. {  
    102.     ASSERT(m1.m_row == m2.m_row && m1.m_col==m2.m_col);  
    103.     CMatrix ret(m1.m_row,m1.m_col);  
    104.     for (int i = 0;i<m1.m_row*m1.m_col;i++)  
    105.     {  
    106.         ret.m_data[i] = m1.m_data[i]+m2.m_data[i];  
    107.         TRACE(_T("ret[%d]=%f\n"),i,ret.m_data[i]);  
    108.     }  
    109.     return ret;  
    110.   
    111. }  
    112. CMatrix operator-(CMatrix& m1,CMatrix& m2)  
    113. {  
    114.     ASSERT(m1.m_row == m2.m_row && m1.m_col==m2.m_col);  
    115.     CMatrix ret(m1.m_row,m1.m_col);  
    116.     for (int i = 0;i<m1.m_row*m1.m_col;i++)  
    117.     {  
    118.         ret.m_data[i] = m1.m_data[i]-m2.m_data[i];  
    119.         TRACE(_T("ret[%d]=%f\n"),i,ret.m_data[i]);  
    120.     }  
    121.     return ret;  
    122. }  
    123. CMatrix operator*(CMatrix& m1,double& a)  
    124. {  
    125.     CMatrix ret(m1);  
    126.     for (int i = 0;i<m1.m_row*m1.m_col;i++)  
    127.     {  
    128.         ret.m_data[i] *=a;  
    129.         TRACE(_T("ret[%d]=%f\n"),i,ret.m_data[i]);  
    130.     }  
    131.     return ret;  
    132. }  
    133. CMatrix operator*(CMatrix& m1,CMatrix& m2)  
    134. {  
    135.     ASSERT(m1.m_col == m2.m_row);  
    136.     CMatrix ret(m1.m_row,m2.m_col);  
    137.     for (int i= 0;i<m1.m_row;i++)  
    138.     {  
    139.         for (int j = 0;j<m2.m_col;j++)  
    140.         {  
    141.             double _temp = 0;  
    142.             for (int k = 0;k<m1.m_col;k++)  
    143.             {  
    144.                 _temp += m1.m_data[i*m1.m_row+k]*m2.m_data[k*m2.m_row+j];  
    145.             }  
    146.             ret.m_data[i*m1.m_row+j] = _temp;  
    147.         }  
    148.     }  
    149.     return ret;  
    150. }  
    151. CMatrix& CMatrix::transpose()  
    152. {  
    153.     double* _newData = new double[m_row*m_col];  
    154.       
    155.     for (int i = 0;i<m_row;i++)  
    156.     {  
    157.         for (int j=0;j<m_col;j++)  
    158.         {  
    159.             _newData[j*m_col+i] = m_data[i*m_row+j];  
    160.         }  
    161.     }  
    162.     delete m_data;  
    163.     m_data = _newData;  
    164.           
    165.     return *this;  
    166.       
    167. }  
    168. void CMatrix::nonZero()  
    169. {  
    170.     for (int i = 0;i<m_row;i++)  
    171.     {  
    172.         for (int j = 0;j<m_col;j++)  
    173.         {  
    174.             if(m_data[i*m_row+j]<0)  
    175.             {  
    176.                 m_data[i*m_row+j]=0;  
    177.             }  
    178.         }  
    179.     }  
    180. }  
    181. #ifdef _DEBUG  
    182. void CMatrix::display()  
    183. {  
    184.     std::cout<<"[\n";  
    185.     for (int i = 0;i<m_row*m_col;i++)  
    186.     {  
    187.         std::cout<<m_data[i]<<" ,";  
    188.         if ((i+1)%m_row == 0)  
    189.         {  
    190.             std::cout<<std::endl;  
    191.         }  
    192.     }  
    193.     std::cout<<"]"<<std::endl;  
    194. }  
    195. #endif  


    哈尔小波变换函数

    1. /******************************************** 
    2.  *              HAAR小波变换                * 
    3.  ********************************************/  
    4. void CBitMapFile::haarTransform(CFile& file)  
    5. {  
    6.     CMatrix imageMatrix(m_realImageArray,m_height,m_width);  
    7.     CMatrix haarMatrix_r(m_height,m_height);  
    8.     CMatrix haarMatrix_c(m_width,m_width);  
    9. #ifdef _DEBUG  
    10.     imageMatrix.display();  
    11. #endif  
    12.     haarMatrix_c.inital(HAAR);  
    13.     haarMatrix_c = haarMatrix_c.transpose();  
    14.     haarMatrix_r.inital(HAAR);  
    15.     imageMatrix = haarMatrix_r*imageMatrix;  
    16.     double _d = 0.25*sqrt(2.0);  
    17.     imageMatrix = imageMatrix*_d;  
    18.     imageMatrix = imageMatrix*haarMatrix_c;  
    19.     imageMatrix = imageMatrix*_d;  
    20.       
    21.   
    22.     imageMatrix.nonZero();  
    23. #ifdef _DEBUG  
    24.     imageMatrix.display();  
    25. #endif    
    26.       
    27.     double* _correctData = imageMatrix.getData();  
    28.     BYTE* _writeArray = new BYTE[m_sizeImage];  
    29.     memset(_writeArray,0,sizeof(BYTE)*m_sizeImage);  
    30.   
    31.     for (int i = 0,j = 0;i<m_sizeImage;)  
    32.     {  
    33.         _writeArray[i] = (BYTE)_correctData[j];  
    34.         _writeArray[i+1] = (BYTE)_correctData[j];  
    35.         _writeArray[i+2] = (BYTE)_correctData[j];  
    36.         j++;  
    37.         i += 3;  
    38.         if (j%m_width == 0)  
    39.         {  
    40.             for (int k = 0;k<m_addByte;k++)  
    41.             {  
    42.                 _writeArray[i+k] = 0;  
    43.   
    44.             }  
    45.             i += m_addByte;  
    46.         }  
    47.     }  
    48.     file.Write(&m_file_header,sizeof(BITMAPFILEHEADER));  
    49.     file.Write(&m_info_header,sizeof(BITMAPINFOHEADER));  
    50.     file.Write(_writeArray,sizeof(BYTE)*m_sizeImage);  
    51.   
    52.     delete _writeArray;  
    53.     //delete _correctData;  
    54. }  


    处理后图像

    由于bmp格式是倒着存储图像数据的,因为个人时间原因没有将其倒回,所以出现这种现象。

    实验软件可以在这里下载:http://download.csdn.net/detail/smells2/4162515


    展开全文
  • 数字图像处理常用方法总结

    千次阅读 2018-06-03 11:30:48
    做了年的图像处理,可以对一些使用的方法进行总结: 1、图像变换 由于图像阵列很大,直接在空间域中进行处理,涉及计算量很大。因此,往往采用各种图像变换的方法,例如: 傅立叶变换、沃尔什变换、离散余弦...

    做了几年的图像处理,可以对一些使用的方法进行总结:

    • 1、图像变换
      由于图像阵列很大,直接在空间域中进行处理,涉及计算量很大。因此,往往采用各种图像变换的方法,例如:
      傅立叶变换、沃尔什变换、离散余弦变换等间接处理技术,将空间域的处理转换为变换域处理,不仅可减少计算量,而且可获得更有效的处理(如傅立叶变换可在频域中进行数字滤波处理)。

    • 2、图像编码压缩
      图像编码压缩技术可减少描述图像的数据量(即比特数),以便节省图像传输、处理时间和减少所占用的存储器容量。压缩可以在不失真的前提下获得,也可以在允许的失真条件下进行。编码是压缩技术中最重要的方法,它在图像处理技术中是发展最早且比较成熟的技术。

    • 3、图像增强
      图像增强不考虑图像降质的原因,突出图像中所感兴趣的部分。如强化图像高频分量,可使图像中物体轮廓清晰,细节明显;如强化低频分量可减少图像中噪声影响。

    • 4、图像复原
      图像复原要求对图像降质的原因有一定的了解,一般讲应根据降质过程建立“降质模型”,再采用某种滤波方法,恢复或重建原来的图像。

    • 5、图像分割
      图像分割是将图像中有意义的特征部分提取出来,其有意义的特征有图像中的边缘、区域等,这是进一步进行图像识别、分析和理解的基础。

    • 6、图像描述
      最简单的二值图像可采用其几何特性描述物体的特性,一般图像的描述方法采用二维形状描述,它有边界描述和区域描述两类方法。对于特殊的纹理图像可采用二维纹理特征描述。随着图像处理研究的深入发展,已经开始进行三维物体描述的研究,提出了体积描述、表面描述、广义圆柱体描述等方法。

    • 7、图像分类(识别)
      图像分类(识别)属于模式识别的范畴,其主要内容是图像经过某些预处理(增强、复原、压缩)后,进行图像分割和特征提取,从而进行判决分类。

    展开全文
  • 图像处理几种方法

    千次阅读 2017-12-09 19:23:13
    图像处理几种方法1.使用skimage name details name details name details astronaut 宇航员图片 coffee 一杯咖啡图片 lena lena图片 camera 拿相机的人图片 coins 硬币 moon 月亮 checkerboard ...

    图像处理的几种方法

    1.使用skimage

    name details name details name details
    astronaut 宇航员图片 coffee 一杯咖啡图片 lena lena图片
    camera 拿相机的人图片 coins 硬币 moon 月亮
    checkerboard 棋盘 horse page 一页书
    chelsea 小猫图片 hubble_deep_field 星空 text 文字
    clock 时钟 immunohistochemistry 结肠
    import numpy as np
    import scipy
    import matplotlib.pyplot as plt
    from skimage import io,data
    img=data.chelsea()
    img=io.imread('d:/python/loli.jpg')
    #读取图片
    # img=io.imread('d:/python/loli.jpg',as_grey=True)
    #图片变换
    [m,n,l]=img.shape
    img1=skimage.transform.resize(img,(int(m*0.6),int(n*0.6),l),mode='reflect')
    #保存图片
    io.imsave('d:/python/loli1.jpg',img1)
    io.imshow(img1)
    plt.show()
    # 显示图片信息
    print (type(img))  #显示类型
    print (img.shape)  #显示尺寸
    print (img.shape[0])  #图片宽度
    print (img.shape[1])  #图片高度
    print (img.shape[2])  #图片通道数
    print (img.size)   #显示总像素个数
    print (img.max())  #最大像素值
    print (img.min())  #最小像素值
    print (img.mean()) #像素平均值
    C:\ProgramData\Anaconda2\lib\site-packages\skimage\util\dtype.py:122: UserWarning: Possible precision loss when converting from float64 to uint8
      .format(dtypeobj_in, dtypeobj_out))
    

    这里写图片描述

    <type 'numpy.ndarray'>
    (415L, 518L, 3L)
    415
    518
    3
    644910
    255
    0
    111.793140128
    

    2 使用scipy.misc(miscellaneous routines)不推荐,很多已经deprecated

    Various utilities that don’t have another home.
    Note that Pillow (https://python-pillow.org/) is not a dependency of SciPy, but the image manipulation functions indicated in the list below are not available without it.

    Deprecated functions:

    col 1 col 2
    bytescale(*args, **kwds) bytescale is deprecated!
    fromimage(*args, **kwds) fromimage is deprecated!
    imfilter(*args, **kwds) imfilter is deprecated!
    imread(*args, **kwds) imread is deprecated!
    imresize(*args, **kwds) imresize is deprecated!
    imrotate(*args, **kwds) imrotate is deprecated!
    imsave(*args, **kwds) imsave is deprecated!
    imshow(*args, **kwds) imshow is deprecated!
    toimage(*args, **kwds) toimage is deprecated!
    from scipy import misc
    import matplotlib.pyplot as plt
    import numpy as np
    # 读取图片
    img=misc.imread('d:/python/loli.jpg',mode='RGB')
    # 改变大小
    img1=scipy.misc.imresize(img,(111,80),interp='nearest')
    # 显示图片
    #misc.imshow(img) have been deprecated
    plt.imshow(img)
    plt.show()
    misc.imsave('d:/python/loli1.jpg',img)

    这里写图片描述

    3 使用PIL做图像处理

    3.1 Reading and Writing Images : open( infilename ) , save( outfilename )

    3.2 Cutting and Pasting and Merging Images :

    crop() : 从图像中提取出某个矩形大小的图像。它接收一个四元素的元组作为参数,各元素为(left, upper, right, lower),坐标系统的原点(0, 0)是左上角。
    paste() :
    merge()

    3.3 几何变换

     box = (100, 100, 200, 200)
     region = im.crop(box)
     region.show()
     region = region.transpose(Image.ROTATE_180)
     region.show()
     im.paste(region, box)
     im.show()
    #旋转一幅图片
    def roll(image, delta):
        "Roll an image sideways"
    
        xsize, ysize = image.size
    
        delta = delta % xsize
        if delta == 0: return image
    
        part1 = image.crop((0, 0, delta, ysize))
        part2 = image.crop((delta, 0, xsize, ysize))
        image.paste(part2, (0, 0, xsize-delta, ysize))
        image.paste(part1, (xsize-delta, 0, xsize, ysize))
    
        return image
    #简单的几何变换
    out = im.resize((128, 128))                     #
    out = im.rotate(45)                             #逆时针旋转 45 度角。
    out = im.transpose(Image.FLIP_LEFT_RIGHT)       #左右对换。
    out = im.transpose(Image.FLIP_TOP_BOTTOM)       #上下对换。
    out = im.transpose(Image.ROTATE_90)             #旋转 90 度角。
    out = im.transpose(Image.ROTATE_180)            #旋转 180 度角。
    out = im.transpose(Image.ROTATE_270)            #旋转 270 度角。
    from PIL import Image
    im=Image.open('d:/python/loli.jpg')
    print im.format,im.size,im.mode
    im.show()
    JPEG (518, 415) RGB
    
    box = (100, 100, 200, 200)
    region = im.crop(box)
    region.show()
    region = region.transpose(Image.ROTATE_180)
    region.show()
    im.paste(region, box)
    im.show()
    out = im.resize((128, 128))                     #
    out = im.rotate(45)                             #逆时针旋转 45 度角。
    out = im.transpose(Image.FLIP_LEFT_RIGHT)       #左右对换。
    out = im.transpose(Image.FLIP_TOP_BOTTOM)       #上下对换。
    out = im.transpose(Image.ROTATE_90)             #旋转 90 度角。
    out = im.transpose(Image.ROTATE_180)            #旋转 180 度角。
    out = im.transpose(Image.ROTATE_270) 
    out.show()
    展开全文
  • 图像处理几种滤波

    万次阅读 2018-06-19 01:57:50
    均值滤波均值滤波,是图像处理中最常用的手段,从频率域观点来看均值滤波是一低通滤波器,高频信号将会去掉,因此可以帮助消除图像尖锐噪声,实现图像平滑,模糊等功能。理想的均值滤波是用每个像素和它周围像素...
  • 数字图像处理的基本原理和常用方法  数字图像处理是指将图像信号转换成数字信号并利用计算机对其进行处理的过程。图像处理最早出现于 20 世纪 50 年代,当时的电子计算机已经发展到一定水平,人们开始利用计算机来...
  • 图像处理常见二值化方法汇总

    千次阅读 2018-12-18 11:20:50
    图像处理常见二值化方法汇总 图像二值化是图像分析与处理中最常见最重要的处理手段,二值处理方法也非常多。越 精准的方法计算量也越大。本文主要介绍四种常见的二值处理方法,通常情况下可以满 足大多数图像...
  • 常见图像分割方法有以下几种

    万次阅读 2018-04-19 18:33:08
    常见图像分割方法有以下几种:1.基于阈值的分割方法 灰度阈值分割法是一种最常用的并行区域技术,它是图像分割中应用数量最多的一类。阈值分割方法实际上是输入图像f到输出图像g的如下变换: 其中,T为阈值;...
  • 图像处理常用插值方法总结

    千次阅读 2016-11-24 21:48:17
    图像处理常用插值方法总结
  • 几种常用图像处理函数库

    千次阅读 2018-09-20 13:12:17
    from:... 几种常用图像处理函数库 OpenCV OpenCV的全称是:Open Source Computer Vision Library。OpenCV是一个基于(开源)发行的跨平台计算机视觉库,可以运行在Linux、Windows和Mac OS操...
  • 2013-09-21 • 技术文章 • 评论 前言 即使没有计算机图形学基础知识的读者也完全不用担心您是否适合阅读此文,本文的性质...本文主要介绍几种常见计算机图像处理操作的原理,为了操作简便和保证平台兼容性,
  • 也就是说,它实际提供的是各种图像处理算法。若需具体应用,需要组合其算法以实现某个功能。 OpenCV 的全称 Open Source Computer Vision Library,是一个基于BSD许可(开源)发行的跨平台计算机视觉库,又名 “开源...
  • 数字图像处理的技术方法和应用

    万次阅读 2016-11-18 10:56:01
    所谓数字图像处理,是指将图像信号转换成数字信号并利用计算机对其进行处理的过程。20 世纪 50 年代,电子计算机已经发展到一定水平,人们开始利用计算机来处理图形和图像信息,这便是早期的图像处理。早期图像处理...
  • 最近在制作一个安卓上的图像处理软件,感觉调整对比度这个功能,在photoshop上还是比较常用的功能,于是就在软件上加上这个功能。 对比度的定义:简单的来说就是使亮的地方更亮,暗的地方更暗。 但是关于亮与...
1 2 3 4 5 ... 20
收藏数 138,104
精华内容 55,241
关键字:

图像处理的几种常用方法