OpenCV，马赛克常用图像增强算法的实现

import cv2
import numpy as npdef salt(img, img2, n):noff = int((n - 1) / 2)for i in range(noff,img.shape[0]-noff,noff):for j in range(noff,img.shape[1]-noff,noff):# img.shape[0] -- 取得img 的列（图片的高）
            # img.shape[1] -- 取得img 的行（图片的宽）
            # i = int(np.random.random() * img.shape[1]);
            # j = int(np.random.random() * img.shape[0]);

            (b, g, r) = img[i, j]k = np.random.random()#b = img[j, i, 0]
            #g = img[j, i, 1]
            #r = img[j, i, 2]
            for m in range(-noff,  noff):for n in range(-noff, noff):img[i+m, j+n, 0] = bimg[i + m, j + n, 1] = gimg[i + m, j + n, 2] = r#img[i+m, j+n] = 255
            #img[j, i, 1] = 255
            #img[j, i, 2] = 255
    return imgimg = cv2.imread("100900.jpg")
img2 = img.copy()
saltImage = salt(img, img2, 17)cv2.imshow("Salt", saltImage)
cv2.waitKey(0)
cv2.destroyAllWindows()

1、对数图像增强算法

对数图像增强是图像增强的一种常见方法，其公式为： S = c log(r+1)，其中c是常数（以下算法c=255/(log(256)），这样可以实现整个画面的亮度增大。

[cpp] view plaincopy print?

void LogEnhance(IplImage* img, IplImage* dst)
{
// 由于oldPixel:[1,256],则可以先保存一个查找表
uchar lut[256] ={0};
double temp = 255/log(256);
for ( int i =0; i<255; i++)
{
lut[i] = (uchar)(temp* log(i+1)+0.5);
}
for( int row =0; row <img->height; row++)
{
uchar *data = (uchar*)img->imageData+ row* img->widthStep;
uchar *dstData = (uchar*)dst->imageData+ row* dst->widthStep;
for ( int col = 0; col<img->width; col++)
{
for( int k=0; k<img->nChannels; k++)
{
uchar t1 = data[col*img->nChannels+k];
dstData[col*img->nChannels+k] = lut[t1];
}
}
}
}

2、指数图像增强算法

指数图像增强的表达为：S = cR^r，通过合理的选择c和r可以压缩灰度范围，算法以c=1.0/255.0, r=2实现。

[cpp] view plaincopy print?

void ExpEnhance(IplImage* img, IplImage* dst)
{
// 由于oldPixel:[1,256],则可以先保存一个查找表
uchar lut[256] ={0};
double temp = 1.0/255.0;
for ( int i =0; i<255; i++)
{
lut[i] = (uchar)(temp*i*i+0.5);
}
for( int row =0; row <img->height; row++)
{
uchar *data = (uchar*)img->imageData+ row* img->widthStep;
uchar *dstData = (uchar*)dst->imageData+ row* dst->widthStep;
for ( int col = 0; col<img->width; col++)
{
for( int k=0; k<img->nChannels; k++)
{
uchar t1 = data[col*img->nChannels+k];
dstData[col*img->nChannels+k] = lut[t1];
}
}
}
}

3、加Masaic算法

在日常中有时候保密或其他需要将图像马赛克，下面的算法实现图像马赛克功能（原理：用中心像素来表示邻域像素）。

[cpp] view plaincopy print?

uchar getPixel( IplImage* img, int row, int col, int k)
{
return ((uchar*)img->imageData + row* img->widthStep)[col*img->nChannels +k];
}
void setPixel( IplImage* img, int row, int col, int k, uchar val)
{
((uchar*)img->imageData + row* img->widthStep)[col*img->nChannels +k] = val;
}

[cpp] view plaincopy print?

// nSize:为尺寸大小，奇数
// 将邻域的值用中心像素的值替换
void Masic(IplImage* img, IplImage* dst, int nSize)
{
int offset = (nSize-1)/2;
for ( int row = offset; row <img->height - offset; row= row+offset)
{
for( int col= offset; col<img->width - offset; col = col+offset)
{
int val0 = getPixel(img, row, col, 0);
int val1 = getPixel(img, row, col, 1);
int val2 = getPixel(img, row, col, 2);
for ( int m= -offset; m<offset; m++)
{
for ( int n=-offset; n<offset; n++)
{
setPixel(dst, row+m, col+n, 0, val0);
setPixel(dst, row+m, col+n, 1, val1);
setPixel(dst, row+m, col+n, 2, val2);
}
}
}
}
}

0x01. 像素

mport math
for i in range(50, 100 + 1):
    for j in range(2, int(math.sqrt(i)) + 1):
        if i % j == 0:
            break
    else:
        print i

＃第二个：把else的位置与if处于同一缩进。

import math
for i in range(50, 100 + 1):
    for j in range(2, int(math.sqrt(i)) + 1):
        if i % j == 0:
           break
        else:
           print i

＃第三个：在else后加一个break语句。

import math
for i in range(50, 100 + 1):
    for j in range(2, int(math.sqrt(i)) + 1):
        if i % j == 0:
            break
        else:
            print i
            break

import cv2image = cv2.imread("H:\\img\\lena.jpg")#读取图像(b,g,r) = image[0,0]#读取(0,0)像素，

Python中图像像素是按B,G,R顺序存储的print"

位置(0,0)处的像素 - 红:%d,绿:%d,蓝:%d"%(r,g,b)#显示像素值

image[0,0] = (100,150,200)#更改位置(0,0)处的像素

(b,g,r) = image[0,0]#再次读取(0,0)像素

print"位置(0,0)处的像素 - 红:%d,绿:%d,蓝:%d"%(r,g,b)#显示更改后的像素值

corner = image[0:100,0:100]#读取像素块

cv2.imshow("Corner",corner)#显示读取的像素块

image[0:100,0:100] = (0,255,0);#更改读取的像素块

cv2.imshow("Updated",image)#显示图像cv2.waitKey(0)#程序暂停

有两种直接操作图片像素点的方法：

第一种办法就是将一张图片看成一个多维的list，例如对于一张图片im，想要操作第四行第四列的像素点就直接 im[3,3] 就可以获取到这个点的RGB值。

第二种就是使用 OpenCV 提供的 Get1D、 Get2D 等函数。

推荐使用第一种办法吧，毕竟简单。

0x02. 获取行和列像素

有一下四个函数：

cv.GetCol(im, 0): 返回第一列的像素
cv GetCols(im, 0, 10): 返回前 10 列
cv.GetRow(im, 0): 返回第一行
cv.GetRows(im, 0, 10): 返回前 10 行

0x03. 批量处理

需要批量处理所有的像素点的时候，只需要使用for循环迭代处理就可以了：

import cv2.cv as cvim = cv.LoadImage("img/lena.jpg")for i in range(im.height):for j in range(im.width):im[i,j] # 这里可以处理每个像素点

还有一种迭代处理的方式是使用 LineIterator，不过在声明 LineIterator 的时候需要制定处理像素点的开始点和结束点。

import cv2.cv as cvim = cv.LoadImage("img/lena.jpg")li = cv.InitLineIterator(im, (0, 0), (im.rows, im.cols)) #So loop the entire matrixfor (r, g, b) in li:# 这里可以对每个像素点的 r g b 进行处理

娱乐一下，随机获取 5000 个像素点，然后把颜色换成一个随机的值(salt)：

import cv2.cv as cvimport random# 这里也可以使用 Get2D/Set2D 来加载图片
im = cv.LoadImage("img/lena.jpg") for k in range(5000): #Create 5000 noisy pixelsi = random.randint(0,im.height-1)j = random.randint(0,im.width-1)color = (random.randrange(256),random.randrange(256),random.randrange(256))im[i,j] = colorcv.ShowImage("Noize", im)
cv.WaitKey(0)

效果图：

4、曝光过度问题处理

对于曝光过度问题，可以通过计算当前图像的反相（255-image)，然后取当前图像和反相图像的较小者为当前像素位置的值。

// 过度曝光原理：图像翻转，然后求原图与反图的最小值

[cpp] view plaincopy print?

<span style="font-size:12px;">void ExporeOver(IplImage* img, IplImage* dst)
{
for( int row =0; row <img->height; row++)
{
uchar *data = (uchar*)img->imageData+ row* img->widthStep;
uchar *dstData = (uchar*)dst->imageData+ row* dst->widthStep;
for ( int col = 0; col<img->width; col++)
{
for( int k=0; k<img->nChannels; k++)
{
uchar t1 = data[col*img->nChannels+k];
uchar t2 = 255 - t1;
dstData[col*img->nChannels+k] = min(t1,t2);
}
}
}
}</span>

5、高反差保留

高反差保留主要是将图像中颜色、明暗反差较大两部分的交界处保留下来，比如图像中有一个人和一块石头，那么石头的轮廓线和人的轮廓线以及面部、服装等有明显线条的地方会变被保留，儿其他大面积无明显明暗变化的地方则生成中灰色。其表达形式为：dst = r*(img - Blur(img))。

[cpp] view plaincopy print?

Mat HighPass(Mat img)
{
Mat temp;
GaussianBlur(img, temp,Size(7,7),1.6,1.6);
int r=3;
Mat diff = img + r*(img-temp); //高反差保留算法
return diff;
}

测试代码：

[cpp] view plaincopy print?

int main(int argc, char* argv[])
{
const char* Path = "02.bmp";
IplImage *img = cvLoadImage(Path,CV_LOAD_IMAGE_ANYCOLOR);
IplImage *dst = cvCreateImage(cvGetSize(img), img->depth, img->nChannels);
cout<<"输入你要选择的操作："<<endl;
cout<<"1、曝光过度"<<endl;
cout<<"2、加马赛克"<<endl;
cout<<"3、对数增强"<<endl;
cout<<"4、指数增强"<<endl;
cout<<"请输入你的选择:";
int choice = 1;
cin>>choice;
switch (choice)
{
case 1:
ExporeOver(img, dst); //这四个算法中总觉得某个算法有问题
break;
case 2:
Masic(img, dst, 21);
break;
case 3:
LogEnhance(img, dst);
break;
case 4:
ExpEnhance(img, dst);
break;
default:
cout<<"输入错误"<<endl;
break;
}
cvSaveImage("dst.jpg",dst);
cvNamedWindow("SRC",1);
cvNamedWindow("DST", 1);
cvShowImage("SRC", img);
cvShowImage("DST", dst);
cvWaitKey();
return 0;
}

实现在MFC中效果如下（程序有点小问题，“高斯平滑”的效果应该是中值滤波）：