图像处理加噪

2019-11-19 12:52:55 qq_29598161 阅读数 209
  • 本课程教学安排及特色介绍

    通过本课程学习,初学者可以熟练使用opencv4 API完成各种常见的图像分割、识别任务。 中高级学习者也一定能有新的体会和收获。 本课程所讲的例子代码来自于实际开发项目,有较高的实用性。

    205人学习 刘山
    免费试看

要求

对一副图像加噪,进行几何均值,算术均值,谐波,逆谐波处理

待处理图像:

在这里插入图片描述
加噪声函数:

def add_gaussian_noise(image_in, noise_sigma=25):
    temp_image = np.float64(np.copy(image_in))

    h = temp_image.shape[0]
    w = temp_image.shape[1]
    noise = np.random.randn(h, w) * noise_sigma

    noisy_image = np.zeros(temp_image.shape, np.float64)
    if len(temp_image.shape) == 2:
        noisy_image = temp_image + noise
    else:
        noisy_image[:, :, 0] = temp_image[:, :, 0] + noise
        noisy_image[:, :, 1] = temp_image[:, :, 1] + noise
        noisy_image[:, :, 2] = temp_image[:, :, 2] + noise
    """
    print('min,max = ', np.min(noisy_image), np.max(noisy_image))
    print('type = ', type(noisy_image[0][0][0]))
    """
    return noisy_image

def sp_noisy(image, s_vs_p=0.5, amount=0.08):
    out = np.copy(image)
    num_salt = np.ceil(amount * image.size * s_vs_p)
    coords = [np.random.randint(0, i - 1, int(num_salt)) for i in image.shape]
    out[tuple(coords)] = 255
    num_pepper = np.ceil(amount * image.size * (1. - s_vs_p))
    coords = [np.random.randint(0, i - 1, int(num_pepper)) for i in image.shape]
    out[tuple(coords)] = 0
    return out

噪声图

高斯噪声:
在这里插入图片描述
盐噪声:
在这里插入图片描述
胡椒噪声:
在这里插入图片描述

滤波函数

def filter(image, op):
    new_image = np.zeros(image.shape)
    image = cv2.copyMakeBorder(image, 1, 1, 1, 1, cv2.BORDER_DEFAULT)
    for i in range(1, image.shape[0] - 1):
        for j in range(1, image.shape[1] - 1):
            new_image[i - 1, j - 1] = op(image[i - 1:i + 2, j - 1:j + 2])
    new_image = (new_image - np.min(image)) * (255 / np.max(image))
    return new_image.astype(np.uint8)

几何均值滤波器

几何均值可由如下模板进行卷积求得,第三次作业已求过

k1 = np.array([
    [1, 1, 1],
    [1, 1, 1],
    [1, 1, 1]
], np.float32)/9

算术均值滤波器

操作函数:

def GeometricMeanOperator(roi):
    roi = roi.astype(np.float64)
    p = np.prod(roi)
    re = p ** (1 / (roi.shape[0] * roi.shape[1]))
    if re < 0:
        re = 0
    if re > 255:
        re = 255
    return re

效果

高斯:
在这里插入图片描述
盐噪声:
在这里插入图片描述
胡椒噪声
在这里插入图片描述
几何均值不适用于胡椒噪声

谐波均值滤波器

操作函数:

def HMeanOperator(roi):
    roi = roi.astype(np.float64)
    re = roi.shape[0] * roi.shape[1] / np.sum([1/(p+0.0001) for p in roi])
    if re < 0:
        re = 0
    if re > 255:
        re = 255
    return re

效果

高斯:
在这里插入图片描述
盐噪声:
在这里插入图片描述
胡椒噪声:
在这里插入图片描述
谐波均值也不适用于胡椒噪声

逆谐波均值滤波器

操作函数:

def IHMeanOperator(roi, q):
    roi = roi.astype(np.float64)
    return np.mean(roi ** (q + 1)) / np.mean(roi ** q)


def IHMeanAlogrithm(image, q):
    new_image = np.zeros(image.shape)
    image = cv2.copyMakeBorder(image, 1, 1, 1, 1, cv2.BORDER_DEFAULT)
    for i in range(1, image.shape[0] - 1):
        for j in range(1, image.shape[1] - 1):
            new_image[i - 1, j - 1] = IHMeanOperator(image[i - 1:i + 2, j - 1:j + 2], q)
    new_image = (new_image - np.min(image)) * (255 / np.max(image))
    return new_image.astype(np.uint8)

效果

q>0时消除胡椒噪声:
在这里插入图片描述
q<0时消除盐噪声:
在这里插入图片描述

2015-07-24 09:26:49 mao0514 阅读数 2666
  • 本课程教学安排及特色介绍

    通过本课程学习,初学者可以熟练使用opencv4 API完成各种常见的图像分割、识别任务。 中高级学习者也一定能有新的体会和收获。 本课程所讲的例子代码来自于实际开发项目,有较高的实用性。

    205人学习 刘山
    免费试看

图像噪声源于现实世界中数字信号总会受到各种各样的干扰,最终接受的图像和源于的数字信号之间总

是存在一定的差异,对于图像噪声,使用均值滤波和中值滤波来消除图像噪声的做法已经是很常见的图

像消噪手段。

 

一:图像加噪原理

1.     椒盐噪声(Salt And Pepper Noise)

椒盐噪声是一种因为信号脉冲强度引起的噪声,信噪比(Signal NoiseRate)是衡量图像噪声的一个数字指标。

给一副数字图像加上椒盐噪声的处理顺序应该如下:

  1. 指定信噪比 SNR 其取值范围在[0, 1]之间
  2. 计算总像素数目 SP, 得到要加噪的像素数目 NP = SP * (1-SNR)
  3. 随机获取要加噪的每个像素位置P(i, j)
  4. 指定像素值为255或者0。
  5. 重复c, d两个步骤完成所有像素的NP个像素
  6. 输出加噪以后的图像

 

2.     高斯噪声(Gaussian Noise)

高斯噪声的密度取决于公式G(x, sigma) 其中X是代表平均值,sigma代表的标准方差,每个输入像素 Pin, 

一个正常的高斯采样分布公式G(d), 得到输出像素Pout.

       Pout = Pin + XMeans + sigma *G(d)

其中d为一个线性的随机数,G(d)是随机数的高斯分布随机值。

给一副数字图像加上高斯噪声的处理顺序如下:

a.      输入参数sigam 和 X mean

b.      以系统时间为种子产生一个伪随机数

c.      将伪随机数带入G(d)得到高斯随机数

d.      根据输入像素计算出输出像素

e.      重新将像素值防缩在[0 ~ 255]之间

f.       循环所有像素

g.      输出图像

 

二:关键程序解析

1.     椒盐噪声

根据信噪比,获取要加入椒盐噪声的像素数目

int size= (int)(inPixels.length * (1-SNR));

 

随机得到像素,完成椒盐噪声的加入

for(int i=0; i<size; i++) {

int row = (int)(Math.random()* (double)height);

int col = (int)(Math.random()* (double)width);

index= row * width + col;

inPixels[index]= (255 << 24) | (255 << 16) | (255 << 8) | 255;

}

 

2.     高斯噪声

根据标准方差,和伪随机数的范围,首先计算出一个伪随机数d ,根据d得到高斯分布的随机数值,整个代码如下:

    float d = (float)Math.random()*RANDOM_SCOPE - RANDOM_SCOPE/2;

    float sigma2 = sigma*sigma*2;

    float PI2 = (float)Math.PI * 2;

    float sigmaPI2 = (float)Math.sqrt(PI2*sigma);

    float result = (float)Math.exp(-d/sigma2)/sigmaPI2;

伪随机数的范围为[-127~ 127]之间。

 

获取高斯噪声的像素代码如下:

tr = (int)((float)tr + getGaussianValue() + this.means);

tg = (int)((float)tg + getGaussianValue() + this.means);

tb = (int)((float)tb + getGaussianValue() + this.means);

mean是的值为0.

 

三:程序效果如下


加入白色椒盐噪声的图片

 


加入高斯噪声的图片



椒盐噪声的代码如下:

  1. private BufferedImage addSaltAndPepperNoise(BufferedImage src, BufferedImage dst) {  
  2.     int width = src.getWidth();  
  3.        int height = src.getHeight();  
  4.   
  5.        if ( dst == null )  
  6.            dst = createCompatibleDestImage( src, null );  
  7.   
  8.        int[] inPixels = new int[width*height];  
  9.        getRGB( src, 00, width, height, inPixels );  
  10.          
  11.        int index = 0;  
  12.        int size = (int)(inPixels.length * (1-SNR));  
  13.   
  14.        for(int i=0; i<size; i++) {  
  15.         int row = (int)(Math.random() * (double)height);  
  16.         int col = (int)(Math.random() * (double)width);  
  17.         index = row * width + col;  
  18.         inPixels[index] = (255 << 24) | (255 << 16) | (255 << 8) | 255;  
  19.        }  
  20.   
  21.        setRGB( dst, 00, width, height, inPixels );  
  22.        return dst;  
  23. }  

高斯噪声的代码如下:

  1. private BufferedImage gaussianNoise(BufferedImage src, BufferedImage dst) {  
  2.         int width = src.getWidth();  
  3.         int height = src.getHeight();  
  4.   
  5.         if ( dst == null )  
  6.             dst = createCompatibleDestImage( src, null );  
  7.   
  8.         int[] inPixels = new int[width*height];  
  9.         int[][][] tempPixels = new int[height][width][4];   
  10.         int[] outPixels = new int[width*height];  
  11.         getRGB( src, 00, width, height, inPixels );  
  12.         int index = 0;  
  13.         float inMax = 0;  
  14.         float outMax = 0;  
  15.         for(int row=0; row<height; row++) {  
  16.             int ta = 0, tr = 0, tg = 0, tb = 0;  
  17.             for(int col=0; col<width; col++) {  
  18.                 index = row * width + col;  
  19.                 ta = (inPixels[index] >> 24) & 0xff;  
  20.                 tr = (inPixels[index] >> 16) & 0xff;  
  21.                 tg = (inPixels[index] >> 8) & 0xff;  
  22.                 tb = inPixels[index] & 0xff;  
  23.                 if(inMax < tr) {  
  24.                     inMax = tr;  
  25.                 }  
  26.                 if(inMax < tg) {  
  27.                     inMax = tg;  
  28.                 }  
  29.                 if(inMax < tb) {  
  30.                     inMax = tb;  
  31.                 }  
  32.                 tr = (int)((float)tr + getGaussianValue() + this.means);  
  33.                 tg = (int)((float)tg + getGaussianValue() + this.means);  
  34.                 tb = (int)((float)tb + getGaussianValue() + this.means);  
  35.                 if(outMax < tr) {  
  36.                     outMax = tr;  
  37.                 }  
  38.                 if(outMax < tg) {  
  39.                     outMax = tg;  
  40.                 }  
  41.                 if(outMax < tb) {  
  42.                     outMax = tb;  
  43.                 }  
  44.                 tempPixels[row][col][0] = ta;  
  45.                 tempPixels[row][col][1] = tr;  
  46.                 tempPixels[row][col][2] = tg;  
  47.                 tempPixels[row][col][3] = tb;  
  48.             }  
  49.         }  
  50.   
  51.         // Normalization  
  52.         index = 0;  
  53.         float rate = inMax/outMax;  
  54.         for(int row=0; row<height; row++) {  
  55.             int ta = 0, tr = 0, tg = 0, tb = 0;  
  56.             for(int col=0; col<width; col++) {  
  57.                 index = row * width + col;  
  58.                 ta = tempPixels[row][col][0];  
  59.                 tr = tempPixels[row][col][1];  
  60.                 tg = tempPixels[row][col][2];  
  61.                 tb = tempPixels[row][col][3];  
  62.   
  63.                 tr = (int)((float)tr * rate);  
  64.                 tg = (int)((float)tg * rate);  
  65.                 tb = (int)((float)tb * rate);  
  66.                 outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
  67.             }  
  68.         }  
  69.         setRGB( dst, 00, width, height, outPixels );  
  70.         return dst;  
  71.     }  
2020-04-03 12:15:27 XITMan 阅读数 408
  • 本课程教学安排及特色介绍

    通过本课程学习,初学者可以熟练使用opencv4 API完成各种常见的图像分割、识别任务。 中高级学习者也一定能有新的体会和收获。 本课程所讲的例子代码来自于实际开发项目,有较高的实用性。

    205人学习 刘山
    免费试看

高斯噪声(Gaussiannoise)和椒盐噪声(salt-and-peppernoise)均可通过Python库:skimage实现。

#import os              #import语句的作用是用来导入模块,可以出现在程序任何位置
import cv2 as cv        #导入openCV库
import skimage          #导入skimage模块.scikit-image是一个图像处理算法的集合。它是基于scipy的一款图像处理包,它将图片作为numpy数组进行处理,方便进行后续运算。
                        #必须首先安装numpy,scipy,matplotlib
import numpy as np      #导入numpy模块。numpy是python扩展程序库,支持数组和矩阵运算,针对数组运算提供大量数学函数库。
 
 
def boxBlur(img):
    # 使用5x5的滤波核进行平滑
    blur = cv.boxFilter(img,-1,(5, 5))    
    return blur
 
 
def gaussianBlur(img):
    #     使用高斯核进行平滑
    blur = cv.GaussianBlur(img,(5, 5),1.5)
    return blur
 
 
def main():
    # 2. 定义图片类img
    path = r"C:\Users\98238\Desktop\Lenna.jpg"
    img = cv.imread(path)
    start_t = cv.getTickCount()
    # 5. 加噪声,绘图
    ##############################################3
    # add gaussian noise
    
    gauss_noiseImg = skimage.util.random_noise(img, mode='gaussian')# 添加10%的高斯噪声
    gauss_noiseImg=gauss_noiseImg
    salt_noiseImg = skimage.util.random_noise(img, mode='salt')  # 添加椒盐噪声
    
    lb_gauss=cv.medianBlur(gauss_noiseImg.astype('float32'), 1)#中值滤波
    
    lb_salt=cv.medianBlur(salt_noiseImg.astype('float32'), 1)#中值滤波
    print(gauss_noiseImg.dtype, "gaussian noisy image dtype")#输出一个注释
    print(gauss_noiseImg.shape, "gaussian noisy image shape")#输出一个注释
 
    print(salt_noiseImg.dtype, "salt noisy image dtype")#输出一个注释
    print(salt_noiseImg.shape, "salt noisy image shape")#输出一个注释


    cv.namedWindow("Original Image", cv.WINDOW_NORMAL)#输出原图片的标题
    cv.imshow('Original Image', img)#输出原图片
 
    # Gaussian noisy image
    cv.namedWindow("Added Gaussian Noise Image", cv.WINDOW_NORMAL)#输出高斯噪声图片的标题
    cv.imshow('Added Gaussian Noise Image', gauss_noiseImg)#输出高斯噪声图片
 
    # Salt noisy image
    cv.namedWindow("Added Salt Noise Image", cv.WINDOW_NORMAL)#输出椒盐噪声图片的标题
    cv.imshow('Added Salt Noise Image', salt_noiseImg)#输出椒盐噪声图片

    #滤波后的图像
    cv.namedWindow("lbguass Image", cv.WINDOW_NORMAL)#输出滤波后高斯噪声图片标题
    cv.imshow('lbguass Image', lb_gauss)#输出滤波后高斯噪声图片
    cv.namedWindow("lbsalt Image", cv.WINDOW_NORMAL)#输出滤波后椒盐噪声图片标题
    cv.imshow('lbsalt Image', lb_salt)#输出滤波后椒盐噪声图片
 
    #####################################################

    stop_t = ((cv.getTickCount() - start_t) / cv.getTickFrequency()) * 1000#运行时间
 
    print(stop_t, "ms")#输出时间并加上单位

    cv.waitKey(0)
    cv.destroyAllWindows()
 
 
if __name__ == "__main__":
    main()

原图如下
在这里插入图片描述
使用10%的高斯噪声、椒盐噪声,以及中值滤波为3 结果图如下

添加10%高斯噪声后的图片
在这里插入图片描述
添加椒盐后的图片
在这里插入图片描述
使用中值滤波3滤波后的高斯噪声图
在这里插入图片描述
使用中值滤波3滤波后的椒盐噪声图
在这里插入图片描述
改用中值滤波5 滤波滤波后的高斯噪声图
在这里插入图片描述
滤波后的椒盐噪声图
在这里插入图片描述
结论:
经过中值滤波5的滤波后噪声比中值滤波3滤波后的图像少,但是图像也更模糊一些。

2018-07-06 18:31:04 JonyHwang 阅读数 14754
  • 本课程教学安排及特色介绍

    通过本课程学习,初学者可以熟练使用opencv4 API完成各种常见的图像分割、识别任务。 中高级学习者也一定能有新的体会和收获。 本课程所讲的例子代码来自于实际开发项目,有较高的实用性。

    205人学习 刘山
    免费试看

作者:离散梦

欢迎大家给出宝贵的建议!

 

图像处理基本操作和添加噪音(Matlab)

 

图像处理基本操作:

读取图像:

>>imread(' filename ')    

显示图像:

>>imshow( f )

示例:

同时显示另一幅图:

>>figure,imshow( g )

保存图像:

>>imwrite( f, 'filename')

 

添加噪音:

采用函数imnoise来使用噪声污染一幅图像。该函数的基本语法为

g=imnoise( f , type , parameters )

其中,f是输入图像,type是噪声的类型,parameters是参数设置大小

 

g=imnoise( f , 'gaussian' , m , var )将均值为m、方差为var的高斯噪声加到图像f上。默认值为均值是0、方差是0.01的噪声。

示例:

g=imnoise( f , 'localvar' , V )将均值为0、局部方差为V的高斯噪声加到图像f上。其中V是与f大小相同的一个数组,它包含了每个点的理想方差值。【这个函数和下面这个函数我暂时没实现,需要找下问题,请大牛指点】

g=imnoise( f , 'localvar' , image_intensity , var )将均值为0的高斯噪声添加到图像f上,其中噪声的局部方差var是图像f的亮度值的函数。参量image_intensity和var是大小相同的向量,plot(image_intensity , var)绘制出噪声方差和图像亮度的函数关系。向量image_intensity必须包含范围在【0,1】内的归一化亮度值。

示例:

g=imnoise( f , 'salt & pepper' , d )用椒盐噪声污染图像f,其中d是噪声密度(即包含噪声值的图像区域的百分比)。因此,大约有d*numel(f)个像素收到了影响。默认噪声密度为0.05。

示例:

用方程g=f+n*f将乘性噪声添加到图像f上,其中n是均值为0、方差为var的均匀分布的随机噪声。var的默认值为0.04。

示例:

g=imnoise( f , 'poisson' )从数据中生成泊松噪声。

示例:

2012-01-06 15:53:38 jia20003 阅读数 27145
  • 本课程教学安排及特色介绍

    通过本课程学习,初学者可以熟练使用opencv4 API完成各种常见的图像分割、识别任务。 中高级学习者也一定能有新的体会和收获。 本课程所讲的例子代码来自于实际开发项目,有较高的实用性。

    205人学习 刘山
    免费试看

 

图像噪声源于现实世界中数字信号总会受到各种各样的干扰,最终接受的图像和源于的数字信号之间总

是存在一定的差异,对于图像噪声,使用均值滤波和中值滤波来消除图像噪声的做法已经是很常见的图

像消噪手段。

 

一:图像加噪原理

1.     椒盐噪声(Salt And Pepper Noise)

椒盐噪声是一种因为信号脉冲强度引起的噪声,信噪比(Signal NoiseRate)是衡量图像噪声的一个数字指标。

给一副数字图像加上椒盐噪声的处理顺序应该如下:

  1. 指定信噪比 SNR 其取值范围在[0, 1]之间
  2. 计算总像素数目 SP, 得到要加噪的像素数目 NP = SP * (1-SNR)
  3. 随机获取要加噪的每个像素位置P(i, j)
  4. 指定像素值为255或者0。
  5. 重复c, d两个步骤完成所有像素的NP个像素
  6. 输出加噪以后的图像

 

2.     高斯噪声(Gaussian Noise)

高斯噪声的密度取决于公式G(x, sigma) 其中X是代表平均值,sigma代表的标准方差,每个输入像素 Pin, 

一个正常的高斯采样分布公式G(d), 得到输出像素Pout.

       Pout = Pin + XMeans + sigma *G(d)

其中d为一个线性的随机数,G(d)是随机数的高斯分布随机值。

给一副数字图像加上高斯噪声的处理顺序如下:

a.      输入参数sigam 和 X mean

b.      以系统时间为种子产生一个伪随机数

c.      将伪随机数带入G(d)得到高斯随机数

d.      根据输入像素计算出输出像素

e.      重新将像素值防缩在[0 ~ 255]之间

f.       循环所有像素

g.      输出图像

 

二:关键程序解析

1.     椒盐噪声

根据信噪比,获取要加入椒盐噪声的像素数目

int size= (int)(inPixels.length * (1-SNR));

 

随机得到像素,完成椒盐噪声的加入

for(int i=0; i<size; i++) {

int row = (int)(Math.random()* (double)height);

int col = (int)(Math.random()* (double)width);

index= row * width + col;

inPixels[index]= (255 << 24) | (255 << 16) | (255 << 8) | 255;

}

 

2.     高斯噪声

根据标准方差,和伪随机数的范围,首先计算出一个伪随机数d ,根据d得到高斯分布的随机数值,整个代码如下:

    float d = (float)Math.random()*RANDOM_SCOPE - RANDOM_SCOPE/2;

    float sigma2 = sigma*sigma*2;

    float PI2 = (float)Math.PI * 2;

    float sigmaPI2 = (float)Math.sqrt(PI2*sigma);

    float result = (float)Math.exp(-d/sigma2)/sigmaPI2;

伪随机数的范围为[-127~ 127]之间。

 

获取高斯噪声的像素代码如下:

tr = (int)((float)tr + getGaussianValue() + this.means);

tg = (int)((float)tg + getGaussianValue() + this.means);

tb = (int)((float)tb + getGaussianValue() + this.means);

mean是的值为0.

 

三:程序效果如下


加入白色椒盐噪声的图片

 


加入高斯噪声的图片



椒盐噪声的代码如下:

	private BufferedImage addSaltAndPepperNoise(BufferedImage src, BufferedImage dst) {
		int width = src.getWidth();
        int height = src.getHeight();

        if ( dst == null )
            dst = createCompatibleDestImage( src, null );

        int[] inPixels = new int[width*height];
        getRGB( src, 0, 0, width, height, inPixels );
        
        int index = 0;
        int size = (int)(inPixels.length * (1-SNR));

        for(int i=0; i<size; i++) {
        	int row = (int)(Math.random() * (double)height);
        	int col = (int)(Math.random() * (double)width);
        	index = row * width + col;
        	inPixels[index] = (255 << 24) | (255 << 16) | (255 << 8) | 255;
        }

        setRGB( dst, 0, 0, width, height, inPixels );
        return dst;
	}

高斯噪声的代码如下:

private BufferedImage gaussianNoise(BufferedImage src, BufferedImage dst) {
		int width = src.getWidth();
        int height = src.getHeight();

        if ( dst == null )
            dst = createCompatibleDestImage( src, null );

        int[] inPixels = new int[width*height];
        int[][][] tempPixels = new int[height][width][4]; 
        int[] outPixels = new int[width*height];
        getRGB( src, 0, 0, width, height, inPixels );
        int index = 0;
        float inMax = 0;
        float outMax = 0;
        for(int row=0; row<height; row++) {
        	int ta = 0, tr = 0, tg = 0, tb = 0;
        	for(int col=0; col<width; col++) {
        		index = row * width + col;
        		ta = (inPixels[index] >> 24) & 0xff;
                tr = (inPixels[index] >> 16) & 0xff;
                tg = (inPixels[index] >> 8) & 0xff;
                tb = inPixels[index] & 0xff;
                if(inMax < tr) {
                	inMax = tr;
                }
                if(inMax < tg) {
                	inMax = tg;
                }
                if(inMax < tb) {
                	inMax = tb;
                }
                tr = (int)((float)tr + getGaussianValue() + this.means);
                tg = (int)((float)tg + getGaussianValue() + this.means);
                tb = (int)((float)tb + getGaussianValue() + this.means);
                if(outMax < tr) {
                	outMax = tr;
                }
                if(outMax < tg) {
                	outMax = tg;
                }
                if(outMax < tb) {
                	outMax = tb;
                }
                tempPixels[row][col][0] = ta;
                tempPixels[row][col][1] = tr;
                tempPixels[row][col][2] = tg;
                tempPixels[row][col][3] = tb;
        	}
        }

        // Normalization
        index = 0;
        float rate = inMax/outMax;
        for(int row=0; row<height; row++) {
        	int ta = 0, tr = 0, tg = 0, tb = 0;
        	for(int col=0; col<width; col++) {
        		index = row * width + col;
        		ta = tempPixels[row][col][0];
        		tr = tempPixels[row][col][1];
        		tg = tempPixels[row][col][2];
        		tb = tempPixels[row][col][3];

        		tr = (int)((float)tr * rate);
        		tg = (int)((float)tg * rate);
        		tb = (int)((float)tb * rate);
        		outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;
        	}
        }
        setRGB( dst, 0, 0, width, height, outPixels );
        return dst;
	}