圖像處理------噪聲之美 - 隨機噪聲產生 分類： 視頻圖像處理 2015-07-24 09:22 26人閱讀 評論(0) 收藏

數學原理：

首先看兩張圖片，大小均爲256 * 256個像素, 第一張是純藍色

圖一：

第二張是加有隨機噪聲的藍色

 圖二：

產生隨機噪聲的算法簡單的不能再簡單了

假設RGB的R與G顏色份量均爲零, 則 Blue = 255 * Math.Random() 隨機數的取值範圍在

[0, 1]之間, 程序的核心代碼以下：

for(int row=0; row<256; row++) {

                            for(int col=0; col<256; col++) {

b = (int)(255.0d * Math.random());

                                     rgbData[index]= ((clamp(a) & 0xff) << 24) |

                                                                           ((clamp(r)& 0xff) << 16)  |

                                                                           ((clamp(g)& 0xff) << 8)   |

                                                                           ((clamp(b)& 0xff));

                                     index++;

                            }

}

 

上面顯然不是我想要的結果，我想要的是下面兩種：

 圖三：

圖四：

對的，只要咱們對上面的算法稍加改進，就能夠實現這樣漂亮的噪聲效果

實現第二張圖效果的算法缺點在於，它每次都產生一個新的隨機數,假設[0,1] = 255，接着第

二點隨機能夠能爲[0, 2] = 0 第三個點可能隨機值爲[0, 3] = 125, 毫無規律可言，而我但願是

假設第一點隨機[0, 1] = 255則間隔N個點之後再產生下個隨機顏色值[0,N+1] =125, 在下一

個點則爲[0, 2N +1] = 209…..因而問題產生了， 咱們怎麼計算[1, N]的之間的每一個像素點的值

哇，這個問題不正是關於圖像放縮的插值問題嘛，一個最簡單的選擇是雙線性插值算法，

算法解釋參考這裏：http://blog.csdn.net/jia20003/article/details/6915185

有了算法選擇，下面的問題就是咱們怎麼計算點值的問題，面臨兩個選擇，一個值照搬雙線

性插值中的計算方法，可是有點不天然，咱們想要的是噪聲，顯然線性的計算結果不是最好

的最好的選擇，cos(x)如何，在[0, PI]內是遞減，在[PI,2PI]內是遞增，並且值的範圍在[-1, 1]

之間，而咱們的隨機數值要在[0, 1]之間因而綜合上述考慮咱們有cos(PI + (x-x0/x1-x0)* PI) + 1, 現

在計算出來的值是[0, 1]區間以內 根據插值公式最終有：

y= (y1-y0) * cos(PI + (x-x0/x1-x0) * PI) + 1 + y0

 

其中[x, y]表明要計算的點，周圍四個採樣點爲：[x-N, y-N], [x+N,y-N], [x-N, y+N], [x+N, y+N ]

運用雙線性插值原理便可計算出[1, N]個每一個像素點的值。

關鍵代碼實現及解釋：

獲取四個採樣點，及其值，而後使用相似雙線性算法計算出[x,y]的隨機數值進而計算出像素值

的程序代碼以下：

// bi-line interpolation algorithm here!!!
    Double GetColor(int x, int y, int M, int colorType)
    {
       int x0 = x - (x % M);
       int x1 = x0 + M;
       int y0 = y - (y % M);
       int y1 = y0 + M;

        Double x0y0 = Noise(x0,y0, colorType);
        Double x1y0 = Noise(x1,y0, colorType);
        Double x0y1 = Noise(x0,y1, colorType);
        Double x1y1 = Noise(x1,y1, colorType);

        Double xx0 =Interpolate(x0, x0y0, x1, x1y0, x);
        Double xx1 = Interpolate(x0,x0y1, x1, x1y1, x);

        Double N =Interpolate(y0, xx0, y1, xx1, y);
        return N;
    }

根據兩個點計算插入值的公式代碼以下：

return (1.0 + Math.cos(Math.PI +  (Math.PI / (x1-x0)) * (x-x0))) / 2.0
* (xx1-xx0) + xx0;

對一張圖像實現隨機噪聲值得出像素值計算的代碼以下：

              for(int row=0; row<256; row++) {
    for(int col=0; col<256; col++) {
        // set random color value for each pixel
        r = (int)(255.0d * GetColor(row, col, intervalPixels, 1));
        g = (int)(255.0d * GetColor(row, col, intervalPixels, 2));
        b = (int)(255.0d * GetColor(row, col, intervalPixels, 4));

        rgbData[index] = ((clamp(a) & 0xff) << 24) |
                        ((clamp(r) & 0xff) << 16)  |
                        ((clamp(g) & 0xff) << 8)   |
                        ((clamp(b) & 0xff));
        index++;
    }
}

徹底源代碼以下：

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.util.Random;

import javax.swing.JComponent;
import javax.swing.JFrame;

public class RandomNoiseImage extends JComponent {

    /**
     *
     */
    private static final long serialVersionUID = -2236160343614397287L;
    private BufferedImage image = null;
    private double[] blue_random;
    private double[] red_random;
    private double[] green_random;
    private int intervalPixels = 40; // default

    public RandomNoiseImage() {
        super();
        this.setOpaque(false);
    }

    protected void paintComponent(Graphics g) {
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2.drawImage(getImage(), 5, 5, image.getWidth(), image.getHeight(), null);
    }

    private BufferedImage getImage() {
        if(image == null) {
            image = new BufferedImage(256, 256, BufferedImage.TYPE_INT_ARGB);
            int[] rgbData = new int[256*256];
            generateNoiseImage(rgbData);
            setRGB(image, 0, 0, 256, 256, rgbData);
        }
        return image;
    }

    private void generateNoiseImage(int[] rgbData) {
        int index = 0;
        int a = 255;
        int r = 0;
        int g = 0;
        int b = 0;
        int sum = 256 * 256;
        blue_random = new double[sum];
        red_random = new double[sum];
        green_random = new double[sum];
        Random random = new Random();
        for(int i=0; i< sum; i++) {
            blue_random[i] = random.nextDouble();
            red_random[i] = random.nextDouble();
            green_random[i] = random.nextDouble();
        }


        for(int row=0; row<256; row++) {
            for(int col=0; col<256; col++) {
                // set random color value for each pixel
                r = (int)(255.0d * GetColor(row, col, intervalPixels, 1));
                g = (int)(255.0d * GetColor(row, col, intervalPixels, 2));
                b = (int)(255.0d * GetColor(row, col, intervalPixels, 4));

                rgbData[index] = ((clamp(a) & 0xff) << 24) |
                                ((clamp(r) & 0xff) << 16)  |
                                ((clamp(g) & 0xff) << 8)   |
                                ((clamp(b) & 0xff));
                index++;
            }
        }

    }

    private int clamp(int rgb) {
        if(rgb > 255)
            return 255;
        if(rgb < 0)
            return 0;
        return rgb;
    }

    // bi-line interpolation algorithm here!!!
    Double GetColor(int x, int y, int M, int colorType)
    {
        int x0 = x - (x % M);
        int x1 = x0 + M;
        int y0 = y - (y % M);
        int y1 = y0 + M;

        Double x0y0 = Noise(x0, y0, colorType);
        Double x1y0 = Noise(x1, y0, colorType);
        Double x0y1 = Noise(x0, y1, colorType);
        Double x1y1 = Noise(x1, y1, colorType);

        Double xx0 = Interpolate(x0, x0y0, x1, x1y0, x);
        Double xx1 = Interpolate(x0, x0y1, x1, x1y1, x);

        Double N = Interpolate(y0, xx0, y1, xx1, y);
        return N;
    }

    // algorithm selection here !!!
    private Double Interpolate(double x0, double xx0, double x1, double xx1, double x) {

        return (1.0 + Math.cos(Math.PI +
                  (Math.PI / (x1-x0)) * (x-x0))) / 2.0 * (xx1-xx0) + xx0;
    }

    Double Noise(int x, int y, int colorType)
    {
        if(colorType == 1) {
            if (x < 256 && y < 256)
                return red_random[y * 256 + x];
            else
                return 0.0;
        } else if(colorType == 2) {
            if (x < 256 && y < 256)
                return green_random[y * 256 + x];
            else
                return 0.0;
        } else {
            if (x < 256 && y < 256)
                return blue_random[y * 256 + x];
            else
                return 0.0;
        }
    }

    public void setRGB( BufferedImage image, int x, int y, int width, int height, int[] pixels ) {
        int type = image.getType();
        if ( type == BufferedImage.TYPE_INT_ARGB || type == BufferedImage.TYPE_INT_RGB )
            image.getRaster().setDataElements( x, y, width, height, pixels );
        else
            image.setRGB( x, y, width, height, pixels, 0, width );
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Noise Art Panel");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().setLayout(new BorderLayout());

        // Display the window.
        frame.getContentPane().add(new RandomNoiseImage(), BorderLayout.CENTER);
        frame.setPreferredSize(new Dimension(280,305));
        frame.pack();
        frame.setVisible(true);
    }
}