• 柏林噪声产生火焰等纹理 分类： 视频图像处理 2015-07-24 09:32 29人阅读 评论(0) 收藏

    柏林噪声是一种特殊的随机噪声，即对于每个给定的值产生的随机数是唯一的，但是不同的

    值产生不同的随机数。关于柏林噪声更详细的解释可以参考这里：

    http://freespace.virgin.net/hugo.elias/models/m_perlin.htm

     

    本文主要是探讨如何使用柏林噪声产生火焰效果与乌云效果的纹理，在解释实现代码之前，

    首先来看一下影响柏林噪声效果的两个参数音度(Octave) 与余辉(Persistence)，可以调节

    纹理的大小和密度。

     

    最终实现的火焰纹理效果


    最终实现的乌云纹理效果


    最终实现的草地纹理效果–怎么感觉有点魔兽中精灵族的草地啊，哈哈


    代码解释

    首先产生随机空白噪声，使用随机空白噪声产生柏林噪声，最后将柏林噪声映射为RGB值

    输出到指定大小的图像中，代码如下:

    float[][] whiteNoise = GenerateWhiteNoise(rows, cols);

    float[][] perlinNoise = GeneratePerlinNoise(whiteNoise, 6); //

    float[][] colorData = MapGray(perlinNoise);

     

    白噪声产生主要是利用JAVA中的系统时间作为种子，产生[0~1]之间的噪声数组

    代码如下：

    public float[][] GenerateWhiteNoise(int width, int height)

    {

    Random random = new Random(System.currentTimeMillis());    

    float[][] noise = new float[width][height];

    for (int i = 0; i < width; i++)

    {

            for (int j = 0; j <height; j++)

            {

                noise[i][j] = (float)random.nextDouble();

            }

        }

        return noise;

    }

     

    柏林噪声的产生稍微复杂一点点，首先把上面的白噪声数据带入，利用插值公式产生平滑的噪声

    数据，具体要产生几组平滑噪声数据取决于音度(Octave)参数。本程序的插值公式非常简单，

    代码如下：

    public float Interpolate(float x0, float x1, float alpha)

    {

    return x0 * (1 - alpha) + alpha * x1;

    }

    最后把这些组的平滑噪声加上不同的振幅混合在一起产生一个输出数组结果即为柏林噪声。

    完成上面这些还不足以产生那些效果震撼的纹理，另外一个顶级秘诀在于怎么把柏林噪声

    映射到你想要的RGB值。代码如下：

        float[][] MapGradient(float[][] perlinNoise)

        {

           int width =perlinNoise.length;

           int height =perlinNoise[0].length;

           float[][] image = new float[width][height];

           int ta=0, tr=0, tb=0,tg=0;

           for (int i = 0; i <width; i++)

           {

              for (int j = 0; j <height; j++)

              {

              ta = 255;

              int u = (int)(perlinNoise[i][j] * (float)angryFireColorTable.length);

              tr = (int)angryFireColorTable[u][0];

              tg = (int)angryFireColorTable[u][1];

              tb = (int)angryFireColorTable[u][2];

              image[i][j] = (ta <<24) | (tr << 16) | (tg << 8) | tb;

              }

           }

          

           return image;

        }

    程序完全源代码如下：

    [java] view plaincopy
    1. package com.gloomyfish.perlin.noise;  
    2.   
    3. import java.util.Random;  
    4.   
    5. public class PerlinNoiseCreator {  
    6.       
    7.     private int[][] angryFireColorTable = {  
    8.             {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},  
    9.             {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},  
    10.             {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},  
    11.             {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},  
    12.             {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},  
    13.             {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},  
    14.             {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},  
    15.             {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 204},    {255, 255, 199},      
    16.             {255, 255, 199},    {255, 255, 197},    {255, 255, 197},    {255, 255, 193},    {255, 255, 193},  
    17.             {255, 255, 191},    {255, 255, 191},    {255, 255, 189},    {255, 255, 189},    {255, 255, 185},  
    18.             {255, 255, 185},    {255, 255, 183},    {255, 255, 183},    {255, 255, 179},    {255, 255, 179},  
    19.             {255, 255, 177},    {255, 255, 177},    {255, 255, 175},    {255, 255, 175},    {255, 255, 171},          
    20.             {255, 255, 171},    {255, 255, 169},    {255, 255, 169},    {255, 255, 167},    {255, 255, 167},  
    21.             {255, 255, 163},    {255, 255, 161},    {255, 255, 157},    {255, 255, 155},    {255, 255, 153},  
    22.             {255, 251, 149},    {255, 249, 147},    {255, 246, 144},    {255, 244, 142},    {255, 242, 140},  
    23.             {253, 244, 205},    {248, 246, 197},    {248, 246, 187},    {248, 245, 178},    {248, 245, 168},  
    24.             {247, 245, 160},    {248, 243, 149},    {247, 244, 141},    {249, 243, 133},    {248, 243, 123},  
    25.             {249, 242, 112},    {248, 242, 102},    {248, 242, 92}, {247, 241, 81}, {248, 241, 73},  
    26.             {247, 240, 63}, {249, 239, 53}, {247, 239, 42}, {249, 238, 32}, {249, 238, 26},  
    27.             {248, 234, 21}, {248, 231, 21}, {250, 224, 25}, {248, 218, 24}, {249, 214, 26},  
    28.             {249, 209, 26}, {252, 204, 32}, {251, 198, 32}, {251, 191, 33}, {251, 186, 34},  
    29.             {250, 179, 35}, {252, 176, 38}, {252, 169, 41}, {252, 164, 41}, {254, 157, 44},  
    30.             {254, 151, 46}, {253, 145, 47}, {254, 141, 49}, {251, 136, 47}, {253, 135, 48},  
    31.             {251, 130, 47}, {250, 129, 46}, {249, 126, 46}, {247, 124, 44}, {246, 120, 43},  
    32.             {244, 118, 41}, {243, 115, 42}, {241, 113, 40}, {242, 111, 41}, {240, 109, 39},  
    33.             {239, 104, 40}, {236, 101, 37}, {234, 99, 35},  {235, 97, 34},  {232, 93, 34},  
    34.             {231, 91, 32},  {229, 88, 32},  {227, 86, 30},  {227, 83, 30},  {225, 81, 28},  
    35.             {224, 78, 27},  {222, 76, 25},  {223, 72, 27},  {221, 70, 25},  {219, 66, 24},  
    36.             {216, 63, 22},  {216, 58, 21},  {212, 54, 19},  {210, 50, 18},  {209, 45, 17},  
    37.             {206, 40, 14},  {206, 37, 14},  {203, 32, 12},  {200, 29, 9},   {200, 24, 9},  
    38.             {197, 21, 6},   {195, 17, 7},   {191, 13, 3},   {190, 7, 3},    {188, 5, 1},  
    39.             {184, 2, 0},    {180, 0, 0},    {178, 0, 0},    {174, 0, 0},    {172, 0, 0},  
    40.             {169, 1, 0},    {164, 0, 1},    {160, 0, 0},    {158, 0, 0},    {154, 0, 0},  
    41.             {150, 0, 0},    {146, 0, 0},    {144, 0, 0},    {140, 0, 1},    {136, 0, 2},  
    42.             {133, 0, 1},    {130, 0, 0},    {126, 1, 0},    {124, 0, 2},    {120, 0, 1},  
    43.             {116, 0, 0},    {112, 0, 0},    {109, 1, 1},    {104, 0, 0},    {103, 0, 1},  
    44.             {98, 0, 0}, {95, 0, 0}, {92, 1, 0}, {92, 1, 0}, {90, 0, 0},  
    45.             {89, 1, 0}, {88, 0, 0}, {86, 0, 0}, {86, 0, 0}, {84, 0, 0},  
    46.             {84, 0, 0}, {82, 1, 0}, {82, 1, 0}, {80, 0, 0}, {80, 0, 0},  
    47.             {79, 1, 1}, {78, 0, 0}, {76, 0, 0}, {76, 0, 0}, {74, 0, 0},  
    48.             {74, 0, 0}, {72, 0, 1}, {72, 0, 1}, {70, 0, 0}, {70, 0, 0},  
    49.             {69, 1, 2}, {68, 0, 1}, {66, 0, 1}, {66, 0, 1}, {64, 0, 0},  
    50.             {62, 1, 0}, {61, 1, 1}, {60, 0, 0}, {60, 0, 0}, {60, 0, 0},  
    51.             {58, 0, 0}, {58, 0, 0}, {56, 0, 1}, {56, 0, 1}, {54, 0, 0},  
    52.             {54, 0, 0}, {52, 1, 0}, {51, 0, 0}, {50, 0, 1}, {50, 0, 1},  
    53.             {49, 1, 1}, {48, 0, 0}, {46, 0, 0}, {46, 0, 0}, {44, 0, 1},  
    54.             {42, 0, 1}, {42, 0, 1}, {40, 0, 0}, {40, 0, 0}, {39, 0, 0},  
    55.             {38, 0, 0}, {38, 0, 0}, {36, 0, 0}, {35, 0, 0}, {34, 0, 0},  
    56.             {34, 0, 0}, {32, 0, 1}, {30, 0, 0}, {30, 0, 0}, {29, 1, 0},  
    57.             {28, 0, 0}, {28, 0, 0}, {26, 0, 1}, {24, 0, 0}, {22, 1, 0},  
    58.             {22, 1, 0}, {21, 1, 0}, {20, 0, 0}, {19, 1, 1}, {19, 1, 1},  
    59.             {16, 0, 0}, {16, 0, 0}, {16, 0, 0}, {14, 0, 0}, {12, 0, 0},  
    60.             {12, 0, 0}, {11, 1, 0}, {10, 0, 0}, {9, 1, 0},  {8, 0, 0},  
    61.             {6, 0, 0},  {6, 0, 0},  {5, 1, 0},  {4, 0, 0},  {2, 1, 0},  
    62.             {2, 1, 0},  {1, 1, 1},  {0, 0, 0},  {0, 0, 0},  {0, 0, 0},  
    63.         };  
    64.   
    65.       
    66.     public void generateNoise(int[] noiseData, int rows, int cols) {  
    67.   
    68.         float[][] whiteNoise = GenerateWhiteNoise(rows, cols);  
    69.         float[][] perlinNoise = GeneratePerlinNoise(whiteNoise, 6); // default value is 6  
    70.         //float[][] colorData = MapGradient(perlinNoise);  
    71.         float[][] colorData = MapGray(perlinNoise);  
    72.         int index = 0;  
    73.         for(int row = 0; row<rows; row++) {  
    74.             for(int col=0; col<cols; col++) {  
    75.                 index = row * cols + col;  
    76.                 noiseData[index] = (int)colorData[row][col];  
    77.             }  
    78.         }  
    79.     }  
    80.       
    81.     public float[][] GenerateWhiteNoise(int width, int height)  
    82.     {  
    83.         Random random = new Random(System.currentTimeMillis()); //Seed to 0 for testing  
    84.         float[][] noise = new float[width][height];  
    85.        
    86.         for (int i = 0; i < width; i++)  
    87.         {  
    88.             for (int j = 0; j < height; j++)  
    89.             {  
    90.                 noise[i][j] = (float)random.nextDouble();  
    91.             }  
    92.         }  
    93.        
    94.         return noise;  
    95.     }  
    96.       
    97.     public float[][] GenerateSmoothNoise(float[][] baseNoise, int octave)  
    98.     {  
    99.        int width = baseNoise.length;  
    100.        int height = baseNoise[0].length;  
    101.        
    102.        float[][] smoothNoise = new float[width][height];  
    103.        
    104.        int samplePeriod = 1 << octave; // calculates 2 ^ k  
    105.        float sampleFrequency = 1.0f / samplePeriod;  
    106.        
    107.        for (int i = 0; i < width; i++)  
    108.        {  
    109.           //calculate the horizontal sampling indices  
    110.           int sample_i0 = (i / samplePeriod) * samplePeriod;  
    111.           int sample_i1 = (sample_i0 + samplePeriod) % width; //wrap around  
    112.           float horizontal_blend = (i - sample_i0) * sampleFrequency;  
    113.        
    114.           for (int j = 0; j < height; j++)  
    115.           {  
    116.              //calculate the vertical sampling indices  
    117.              int sample_j0 = (j / samplePeriod) * samplePeriod;  
    118.              int sample_j1 = (sample_j0 + samplePeriod) % height; //wrap around  
    119.              float vertical_blend = (j - sample_j0) * sampleFrequency;  
    120.        
    121.              //blend the top two corners  
    122.              float top = Interpolate(baseNoise[sample_i0][sample_j0],  
    123.                 baseNoise[sample_i1][sample_j0], horizontal_blend);  
    124.        
    125.              //blend the bottom two corners  
    126.              float bottom = Interpolate(baseNoise[sample_i0][sample_j1],  
    127.                 baseNoise[sample_i1][sample_j1], horizontal_blend);  
    128.        
    129.              //final blend  
    130.              smoothNoise[i][j] = Interpolate(top, bottom, vertical_blend);  
    131.           }  
    132.        }  
    133.        
    134.        return smoothNoise;  
    135.     }  
    136.       
    137.     public float Interpolate(float x0, float x1, float alpha)  
    138.     {  
    139.        return x0 * (1 - alpha) + alpha * x1;  
    140.     }  
    141.       
    142.     public float[][] GeneratePerlinNoise(float[][] baseNoise, int octaveCount)  
    143.     {  
    144.        int width = baseNoise.length;  
    145.        int height = baseNoise[0].length;  
    146.        
    147.        float[][][] smoothNoise = new float[octaveCount][][]; //an array of 2D arrays containing  
    148.        
    149.        float persistance = 0.5f; // default value is 0.5f  
    150.        
    151.        //generate smooth noise  
    152.        for (int i = 0; i < octaveCount; i++)  
    153.        {  
    154.            smoothNoise[i] = GenerateSmoothNoise(baseNoise, i);  
    155.        }  
    156.        
    157.         float[][] perlinNoise = new float[width][height];  
    158.         float amplitude = 1.0f;  
    159.         float totalAmplitude = 0.0f;  
    160.        
    161.         //blend noise together  
    162.         for (int octave = octaveCount - 1; octave >= 0; octave--)  
    163.         {  
    164.            amplitude *= persistance;  
    165.            totalAmplitude += amplitude;  
    166.        
    167.            for (int i = 0; i < width; i++)  
    168.            {  
    169.               for (int j = 0; j < height; j++)  
    170.               {  
    171.                  perlinNoise[i][j] += smoothNoise[octave][i][j] * amplitude;  
    172.               }  
    173.            }  
    174.         }  
    175.        
    176.        //normalization  
    177.        for (int i = 0; i < width; i++)  
    178.        {  
    179.           for (int j = 0; j < height; j++)  
    180.           {  
    181.              perlinNoise[i][j] /= totalAmplitude;  
    182.           }  
    183.        }  
    184.        
    185.        return perlinNoise;  
    186.     }  
    187.       
    188.     float[][] MapGray(float[][] perlinNoise)  
    189.     {  
    190.        int width = perlinNoise.length;  
    191.        int height = perlinNoise[0].length;  
    192.        float[][] image = new float[width][height];  
    193.        int ta=0, tr=0, tb=0, tg=0;  
    194.        for (int i = 0; i < width; i++)  
    195.        {  
    196.           for (int j = 0; j < height; j++)  
    197.           {  
    198.               ta = 255;  
    199.               int u = (int)(perlinNoise[i][j] * (float)80.0);  
    200.               tr = u+100;  
    201.               tg = u+100;  
    202.               tb = u+100;  
    203.               //ta = (int)(255.0f * perlinNoise[i][j]);  
    204.               image[i][j] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
    205.                 
    206.           }  
    207.        }  
    208.          
    209.        return image;  
    210.     }  
    211.       
    212.     float[][] MapGradient(float[][] perlinNoise)  
    213.     {  
    214.        int width = perlinNoise.length;  
    215.        int height = perlinNoise[0].length;  
    216.        float[][] image = new float[width][height];  
    217.        int ta=0, tr=0, tb=0, tg=0;  
    218.        for (int i = 0; i < width; i++)  
    219.        {  
    220.           for (int j = 0; j < height; j++)  
    221.           {  
    222.               ta = 255;  
    223.               int u = (int)(perlinNoise[i][j] * (float)angryFireColorTable.length);  
    224.               tr = (int)angryFireColorTable[u][0];  
    225.               tg = (int)angryFireColorTable[u][1];  
    226.               tb = (int)angryFireColorTable[u][2];  
    227.               image[i][j] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
    228.           }  
    229.        }  
    230.          
    231.        return image;  
    232.     }  
    233.   
    234. }  

    版权声明：本文为博主原创文章，未经博主允许不得转载。
  • 相关阅读:
    js兼容性问题总结
    style设置/获取样式的问题 和 offsetWidth/offsetHeight的问题
    常用SQL总结
    完美运动框架，兼容性好，可多次调用
    JS—实现拖拽
    java设计模式——享元模式
    java设计模式——适配器模式
    java设计模式——装饰者模式
    java设计模式——外观模式(门面模式)
    java设计模式——单例模式(三)
  • 原文地址：https://www.cnblogs.com/mao0504/p/4706375.html
Copyright © 2020-2023  润新知