A. OpenCV C++（四）----对比度增强
对比度增强或者称为对比度拉伸就是图像增强技术的一种，它主要解决由于图像的灰度级范围较小造成的对比度较低的问题，目的就是将输出图像的灰度级放大到指定的程度，使得图像中的细节看起来更加清晰。对比 度增强有几种常用的方法，如线性变换、分段线性变换、伽马变换、直方图正规化、直方图均衡化、局部自适应直方图均衡化等。
灰度直方图是图像灰度级的函数， 用来描述每个灰度级在图像矩阵中的像素个数或者占有率（概率）。
OpenCV提供了函数 calcHist 来实现直方图的构建，但是在计算8位图的灰度直方图 时，它使用起来略显复杂。下面是OpenCV源码
可以定义函数 calcGrayHist 来计算灰度直方图，其中输入参数为8位图，将返回的灰度直方图存储为一个1行256列的 Mat 类型。
图像对比度是通过灰度级范围来度量的，而灰度级范围可通过观察灰度直方图得到，灰度级范围越大代表对比度越高；反之，对比度越低，低对比度的图像在视觉上给人的感觉是看起来不够清晰，所以通过算法调整图像的灰度值，从而调整图像的对比度是有必要的。最简单的一种对比度增强方法是通过灰度值的线性变换来实现的。
当a=1，b=0时，O为I的一个副本；如果a>1，则输出图像O的对 比度比I 有所增大；如果0<a< 1，则O的对比度比I有所减小。而b值的改变，影响的是输出图像的亮度，当b> 0时，亮度增加；当b<0时，亮度减小。
在OpenCV中实现一个常数与矩阵相乘有多种方式。
1、convertTo
注：当输出矩阵的数据类型是 CV_8U 时， 大于255的值会自动截断为255
2、矩阵乘法运算
使用乘法运算符“*”， 无论常数是什么数据类型， 输出矩阵的数据类型总是和输入矩阵的数据类型相同，当数据类型是 CV_8U 时，在返回值中将大于255的值自动截断为255。
3、convertScaleAbs
直方图正规化是一种自动选取a和b的值的线性变换方法。
利用 minMaxLoc 函数不仅可以计算出矩阵中的最大值和最小值， 而且可以求出最大 值的位置和最小值的位置。 当然，
在使用过程中如果只想得到最大值和最小值， 则将其 他的变量值设为 NULL 即可。
OpenCV提供的函数： normalize()
使用函数 normalize 对图像进行对比度增强时， 经常令参数 norm_type=NORM_MINMAX ， 和直方图正规化原理详解中提到的计算方法是相同的， 参数 alpha 相当于 Omax ， 参数 beta 相当于 Omin 。 注意， 使用 normalize 可以处理多通道矩阵， 分别对每一个通道进行正规化操作。
非线性变换 。
假设输入图像为I，宽为W、 高为H，首先将其灰度值归一化到[0，1]范围，对于8位 图来说，除以255即可。 I （r， c） 代表归一化后的第r行第c列的灰度值， 输出图像记为 O， 伽马变换就是令 O（r， c） =I（r， c） γ ， 0≤r<H， 0≤c< W，
当γ=1时， 图像不变。 如果图像整体或者感兴趣区域较暗， 则令0< γ< 1可以 增加图像对比度； 相反， 如果图像整体或者感兴趣区域较亮， 则令γ>1可以降低图像对比度。
伽马变换在提升对比度上有比较好的效果， 但是需要手动调节γ值。
全局直方图均衡化操作是对图像I进行改变， 使得输出图像O的灰度直方图 hist O 是“平”的， 即每一个灰度级的像素点个数是“相等”的。 注意，其实这里的“相等”不是严格意义上的等于， 而是约等于，
上述分别为I和O的累加直方图
总结，对于直方图均衡化的实现主要分四个步骤：
OpenCV实现的直方图均衡化函数 equalize-Hist ， 其使用方法很简单， 只支持对 8位图 的处理。
虽然全局直方图均衡化方法对提高对比度很有效，但是均衡化处理以后暗区域的噪声可能会被放大，变得清晰可 见，而亮区域可能会损失信息。为了解决该问题， 提出了自适应直方图均衡化（Aptive Histogram Equalization） 方法。
自适应直方图均衡化首先将图像划分为不重叠的区域块（tiles） ，然后对每一个块分别进行直方图均衡化。 显然， 在没有噪声影响的情况下， 每一个小区域的灰度直方图会被限制在一个小的灰度级范围内； 但是如果有噪声， 每一个分割的区域块执行直方图均衡化后， 噪声会被放大。为了避免出现噪声这种情况， 提出了“限制对比度”（Contrast Limiting） [3]，如果直方图的bin超过了提前预设好的“限制对比度”， 那么会被裁减， 然 后将裁剪的部分均匀分布到其他的bin， 这样就重构了直方图。
OpenCV提供的函数 createCLAHE 构建指向 CLAHE 对象的指针， 其中默认设置“限制 对比度”为40，块的大小为8×8。
B. photoshop 怎么实现直方图均衡化
图形处理中有一种对比度变换，像显示器就有对比度调节，PhotoShop也有图片的对比度修改，对比度的提高可以使图像细节清晰，相反，对比度的减小可以隐藏图像的细节，在一定程度上使图像柔和。
对比度变换其中一种比较简单的方法是直方图均衡化。
所谓直方图就是在某一灰度级的象素个数占整幅图像的象素比 h=nj/N,其中nj是灰度级在j的象素数，N是总象素数，扫描整幅图像得出的h的离散序列就是图像的直方图，h求和必然＝1，所以直方图可以看成是象素对于灰度的概率分布函数。
直方图是高低不齐的，因为象素灰度是随机变化的，直方图均衡化就是用一定的算法使直方图大致平和。
算法如下：
对于一个直方图
设 Pr(r)是原始图像直方图，Ps(s)是均衡化的直方图，
由于其是一个概率分布函数
所以有 Ps(s)ds=Pr(r)dr (编辑关系，ds,dr是积分变量)
因为要进行均衡化，令 Ps(s)=1,
得 ds=Pr(r)dr/1
两边积分得 s=F Pr(r)dr (因为编辑关系，左边F表示积分符号....-__-++)
数字图像是离散的，因此离散化上式得
sk=E{j=0,k}(nj/N) 左式k,j是离散量下标，因为编辑关系，E{0,k}表示下标0到k的连加符号，N是象素总数
由此得出每一象素的sk为均衡化后的正规化灰度（即灰度正规化到[0,1])，统计sk即可得出均衡化后的直方图。
在均衡化过程中可以对每一象素映射到新的实际灰度值sk*255，就实现了图像的变换
（严格理论中应该是灰度正规化到[0,1]区间，然后均衡化后的sk还要量化到原始的正规灰度以实现灰度合并，下面的BCB程序并没有量化，而且255是固定灰度级，因为256色BMP的彩色表就是256个表项)
现在开始实践
用BCB对一BMP灰度图像进行直方图均衡化处理，代码如下
//----------------------------BCB6代码
#include <vcl.h>
#pragma hdrstop
#include<stdio.h>
#include "Unit1.h"
#include"File1.h"
#pragma pack(1)
//BMP文件头
struct BITMAPFILEHEADER_
{
short type;
int bfSize;
short re1,re2;
int Offbits;
};
//BMP信息头
struct BITMAPINFO_
{
long size;
long width,height;
short planes,bitCount;
long comp,sizeImg;
long xpels,ypels;
long used,important;
};
//BMP彩色表项
struct COLOR_
{
char blue,green,red,re;
};
//------将BMP彩色表的数据校正到BCB TColor的数据。
void SwitchColor(long &c)
{
long blue=c& 0x000000ff;
long green=c& 0x0000ff00;
long red=c& 0x00ff0000;
c=(blue<<16) | green | (red>>16);
}
void xxx()
{
FILE *f=fopen("f:\\bbs_prev2.bmp","rb");
if(f==NULL) /*判断文件是否打开成功*/
{
ShowMessage("File open error");
return;
}
fseek(f,0,0);//移动到开头
//----------读BMP文件头
BITMAPFILEHEADER_ *bmph=new BITMAPFILEHEADER_();
if(fread((char*)bmph,sizeof(BITMAPFILEHEADER_),1,f)==NULL)
{
ShowMessage("File read error");
return;
}
//-----------读BMP信息头
BITMAPINFO_ *bmpi=new BITMAPINFO_();
if(fread((char*)bmpi,sizeof(BITMAPINFO_),1,f)==NULL)
{
ShowMessage("File read error2");
return;
}
//--------------读彩色表
long *c=new long[bmph->Offbits-sizeof(BITMAPFILEHEADER_)-sizeof(BITMAPINFO_)];
fread((char*)c,bmph->Offbits-sizeof(BITMAPFILEHEADER_)-sizeof(BITMAPINFO_),1,f);
//----------显示一些信息
Form1->Edit1->Text=IntToStr(bmph->bfSize);
Form1->Edit2->Text=IntToStr(bmpi->width);
Form1->Edit3->Text=IntToStr(bmpi->height);
Form1->Edit4->Text=IntToStr(bmpi->comp);
Form1->Edit5->Text=IntToStr(bmpi->used);
int i,j,k,wc;
long N=bmph->bfSize- bmph->Offbits;//象素总数
unsigned char *image=new char[N]; //位图矩阵
unsigned char *newimage=new char[N];//变换后的位图矩阵
fread(image,N,1,f);//读入位图矩阵
//---------直方图数列初始化
//---------直方图数列用来存储正规化后的灰度
double *h=new double[255];//255个灰度级，保存原始图像正规化灰度直方图数据
for(i=0;i<255;i++)
h[i]=0.0;
double *nh=new double[255];//255个灰度级，保存变换后的图像正规化灰度直方图
for(i=0;i<255;i++)
nh[i]=0.0;
long *count=new long[255]; //每一灰度级的象素数量统计
for(i=0;i<255;i++)
count[i]=0;
for(i=0;i<N;i++)
{
count[image[i]]++;
}
//－－－－－正规化灰度概率统计
for(i=0;i<255;i++)
{
h[i]=count[i]/(double)N;
}
//------正规化新灰度图
double hc;
for(i=0;i<N;i++)
{
hc=0;
for(j=0;j<image[i];j++)
hc+=h[j];
nh[image[i]]+=hc; //保存新正规化灰度图
newimage[i]=hc*255; //保存新图像灰度索引
}
//----------显示直方图
for(i=0;i<255;i++)
{
//原始直方图
Form1->Canvas->MoveTo(10+i,200);
Form1->Canvas->LineTo(10+i,200+h[i]*N);
//新直方图
Form1->Canvas->MoveTo(300+i,200);
Form1->Canvas->LineTo(300+i,200+nh[i]*255);
}
//------显示图形
TColor *tc;
if(bmpi->width%4==0)//-----------因为BMP图像4字节对齐
wc=bmpi->width/4*4;
else
wc=(bmpi->width/4+1)*4;
long a;
long pos=0;
for( i=0;i<bmpi->height;i++)
{
for(j=0;j<wc;j++)
{
//-----原始图形
a= c[image[pos]];
SwitchColor(a);
Form1->Canvas->Pixels[10+j][600-i]=a;
//------新图形
a= c[newimage[pos]];
SwitchColor(a);
Form1->Canvas->Pixels[300+j][600-i]=a;
pos++;
}
}
fclose(f);
}
这个程序使用256色BMP文件，但程序代码是针对灰度图像的，用于彩色图像时得出一些古怪色彩配合而已。
在对灰度图像均衡化时
如果原始图像对比度本来就很高，如果再均衡化则灰度调和，对比度降低。
在泛白缓和的图像中，由于均衡化过程中会合并一些象素灰度，则会增大对比度，这里255灰度级太多，合并不明显。
http://hi..com/j_fo/blog/item/09a6adc3f8078855b319a8ac.html
还有详细的说明和图解
C. 数字图像处理Python实现图像灰度变换、直方图均衡、均值滤波
import CV2
import
import numpy as np
import random
使用的是pycharm
因为最近看了《银翼杀手2049》，里面Joi实在是太好看了所以原图像就用Joi了
要求是灰度图像，所以第一步先把图像转化成灰度图像
# 读入原始图像
img = CV2.imread('joi.jpg')
# 灰度化处理
gray = CV2.cvtColor(img, CV2.COLOR_BGR2GRAY)
CV2.imwrite('img.png', gray)
第一个任务是利用分段函数增强灰度对比，我自己随便写了个函数大致是这样的
def chng(a):
if a < 255/3:
b = a/2
elif a < 255/3*2:
b = (a-255/3)*2 + 255/6
else:
b = (a-255/3*2)/2 + 255/6 +255/3*2
return b
rows = img.shape[0]
cols = img.shape[1]
cover = .deep(gray)
for i in range(rows):
for j in range(cols):
cover[i][j] = chng(cover[i][j])
CV2.imwrite('cover.png', cover)
下一步是直方图均衡化
# histogram equalization
def hist_equal(img, z_max=255):
H, W = img.shape
# S is the total of pixels
S = H * W * 1.
out = img.()
sum_h = 0.
for i in range(1, 255):
ind = np.where(img == i)
sum_h += len(img[ind])
z_prime = z_max / S * sum_h
out[ind] = z_prime
out = out.astype(np.uint8)
return out
covereq = hist_equal(cover)
CV2.imwrite('covereq.png', covereq)
在实现滤波之前先添加高斯噪声和椒盐噪声（代码来源于网络）
不知道这个椒盐噪声的名字是谁起的感觉隔壁小孩都馋哭了
用到了random.gauss()
percentage是噪声占比
def GaussianNoise(src,means,sigma,percetage):
NoiseImg=src
NoiseNum=int(percetage*src.shape[0]*src.shape[1])
for i in range(NoiseNum):
randX=random.randint(0,src.shape[0]-1)
randY=random.randint(0,src.shape[1]-1)
NoiseImg[randX, randY]=NoiseImg[randX,randY]+random.gauss(means,sigma)
if NoiseImg[randX, randY]< 0:
NoiseImg[randX, randY]=0
elif NoiseImg[randX, randY]>255:
NoiseImg[randX, randY]=255
return NoiseImg
def PepperandSalt(src,percetage):
NoiseImg=src
NoiseNum=int(percetage*src.shape[0]*src.shape[1])
for i in range(NoiseNum):
randX=random.randint(0,src.shape[0]-1)
randY=random.randint(0,src.shape[1]-1)
if random.randint(0,1)<=0.5:
NoiseImg[randX,randY]=0
else:
NoiseImg[randX,randY]=255
return NoiseImg
covereqg = GaussianNoise(covereq, 2, 4, 0.8)
CV2.imwrite('covereqg.png', covereqg)
covereqps = PepperandSalt(covereq, 0.05)
CV2.imwrite('covereqps.png', covereqps)
下面开始均值滤波和中值滤波了
就以n x n为例，均值滤波就是用这n x n个像素点灰度值的平均值代替中心点，而中值就是中位数代替中心点，边界点周围补0；前两个函数的作用是算出这个点的灰度值，后两个是对整张图片进行
#均值滤波模板
def mean_filter(x, y, step, img):
sum_s = 0
for k in range(x-int(step/2), x+int(step/2)+1):
for m in range(y-int(step/2), y+int(step/2)+1):
if k-int(step/2) 0 or k+int(step/2)+1 > img.shape[0]
or m-int(step/2) 0 or m+int(step/2)+1 > img.shape[1]:
sum_s += 0
else:
sum_s += img[k][m] / (step*step)
return sum_s
#中值滤波模板
def median_filter(x, y, step, img):
sum_s=[]
for k in range(x-int(step/2), x+int(step/2)+1):
for m in range(y-int(step/2), y+int(step/2)+1):
if k-int(step/2) 0 or k+int(step/2)+1 > img.shape[0]
or m-int(step/2) 0 or m+int(step/2)+1 > img.shape[1]:
sum_s.append(0)
else:
sum_s.append(img[k][m])
sum_s.sort()
return sum_s[(int(step*step/2)+1)]
def median_filter_go(img, n):
img1 = .deep(img)
for i in range(img.shape[0]):
for j in range(img.shape[1]):
img1[i][j] = median_filter(i, j, n, img)
return img1
def mean_filter_go(img, n):
img1 = .deep(img)
for i in range(img.shape[0]):
for j in range(img.shape[1]):
img1[i][j] = mean_filter(i, j, n, img)
return img1
完整main代码如下：
if __name__ == "__main__":
# 读入原始图像
img = CV2.imread('joi.jpg')
# 灰度化处理
gray = CV2.cvtColor(img, CV2.COLOR_BGR2GRAY)
CV2.imwrite('img.png', gray)
rows = img.shape[0]
cols = img.shape[1]
cover = .deep(gray)
for i in range(rows):
for j in range(cols):
cover[i][j] = chng(cover[i][j])
CV2.imwrite('cover.png', cover)
covereq = hist_equal(cover)
CV2.imwrite('covereq.png', covereq)
covereqg = GaussianNoise(covereq, 2, 4, 0.8)
CV2.imwrite('covereqg.png', covereqg)
covereqps = PepperandSalt(covereq, 0.05)
CV2.imwrite('covereqps.png', covereqps)
meanimg3 = mean_filter_go(covereqps, 3)
CV2.imwrite('medimg3.png', meanimg3)
meanimg5 = mean_filter_go(covereqps, 5)
CV2.imwrite('meanimg5.png', meanimg5)
meanimg7 = mean_filter_go(covereqps, 7)
CV2.imwrite('meanimg7.png', meanimg7)
medimg3 = median_filter_go(covereqg, 3)
CV2.imwrite('medimg3.png', medimg3)
medimg5 = median_filter_go(covereqg, 5)
CV2.imwrite('medimg5.png', medimg5)
medimg7 = median_filter_go(covereqg, 7)
CV2.imwrite('medimg7.png', medimg7)
medimg4 = median_filter_go(covereqps, 7)
CV2.imwrite('medimg4.png', medimg4)