柏林噪声和改进版噪声源码和实现思路PerlinNoise&&SimplexNoise

共1个文件

pdf：1个

柏林噪声

noise

PerlinNoise

需积分: 41 119 浏览量 2022-02-06 18:44:03 上传评论收藏 1.1MB ZIP 举报

资源详情

资源评论

资源推荐

收起资源包目录

柏林噪声和改进版噪声源码和实现思路.zip （1个子文件）

柏林噪声和改进版噪声源码和实现思路.pdf 1.11MB

Simplex noise demystified

Stefan Gustavson, Linköping University, Sweden (stegu@itn.liu.se), 2005-03-22

In 2001, Ken Perlin presented “simplex noise”, a replacement for his classic noise algorithm.

Classic “Perlin noise” won him an academy award and has become an ubiquitous procedural

primitive for computer graphics over the years, but in hindsight it has quite a few limitations.

Ken Perlin himself designed simplex noise specifically to overcome those limitations, and he

spent a lot of good thinking on it. Therefore, it is a better idea than his original algorithm. A few

of the more prominent advantages are:

• Simplex noise has a lower computational complexity and requires fewer multiplications.

• Simplex noise scales to higher dimensions (4D, 5D and up) with much less computational

cost, the complexity is for dimensions instead of the of classic Noise.

• Simplex noise has no noticeable directional artifacts.

• Simplex noise has a well-defined and continuous gradient everywhere that can be computed

quite cheaply.

• Simplex noise is easy to implement in hardware.

Sadly, even now in early 2005 very few people seem to understand simplex noise, and almost

nobody uses it, which is why I wrote this. I will try to explain the algorithm a little more thor-

oughly than Ken Perlin had time to do in his course notes from Siggraph 2001 and 2002, and

hopefully make it clear that it is not as difficult to grasp as it first seems.

From what I’ve learned, what confuses people the most is the impenetrable nature of Ken Per-

lin’s reference implementation in Java. He presents very compact and uncommented code to

demonstrate the principle, but that code is clearly not meant to be read as a tutorial. After a few

attempts I gave up on the code and read his paper instead, which was a lot more clear. Not crys-

tal clear, though, as he presents the algorithm mostly in words and code snippets. I would have

appreciated some graphs and figures and a few helpful equations, and that’s what I try to provide

here, to make it easier for others to understand the greatness and beauty of simplex noise. I will

also explain things in one and two dimensions first to make things easier to explain with graphs

and images, and then move on to three and four dimensions.

Classic noise

In order to explain simplex noise, it is helpful to have a good understanding of classic Perlin

noise. I have seen quite a few bad and misinformed explanations in this area, so to make sure

that you have the necessary groundwork done, I will present classic Perlin noise first.

Perlin noise is a so-called gradient noise, which means that you set a pseudo-random gradient

at regularly spaced points in space, and interpolate a smooth function between those points. To

generate Perlin noise in one dimension, you associate a pseudo-random gradient (or slope) for

the noise function with each integer coordinate, and set the function value at each integer coor-

dinate to zero.

For a given point somewhere between two integer points, the value is interpolated between

two values, namely the values that would have been the result if the closest linear slopes from

the left and from the right had been extrapolated to the point in question. This interpolation is

ON() NO2

()

0 1 2 3 4 5

Should be O(N^2)

not linear with distance, because that would not satisfy the constraint that the derivative of the

noise function should be continuous also at the integer points. Instead, a blending function is

used that has zero derivative at its endpoints. Originally, Ken Perlin used the Hermite blending

function , but because it is highly desirable to have a continuous second deriv-

ative for the noise function, he later changed that to suggest a fifth degree polynomial

. These two functions are very similar, but the fifth degree curve also

has a zero second derivative at its endpoints, which makes the noise function have a continuous

second derivative everywhere, and that makes the noise function better suited for the common

computer graphics tasks of surface displacement and bump mapping.

In two dimensions, the integer coordinate points form a regular square grid. At each grid point

a pseudo-random 2D gradient is picked. For an arbitrary point on the surface, the noise value

is computed from the four closest grid points. As for the 1D case, the contribution from each of

the four corners of the square grid cell is an extrapolation of a linear ramp with a constant gra-

dient, with the value zero at its associated grid point.

The value of each gradient ramp is computed by means of a scalar product (dot product) be-

tween the gradient vectors of each grid point and the vectors from the grid points

to the point being evaluated. In equations:

, ,

t() 3t

–=

t() 6t

15t

–10t

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

-2t

-15t

+10t

0 1 2 3 4

j+1

i+1

ij,()i 1 j,+()ij 1+,()i 1 j 1+,+(),,, P

Pxy,()= i floor x()=

floor y()=

gradient at = ij,()g

gradient at i 1+ j,()=

gradient at ij 1+,()= g

gradient at i 1+ j 1+,()=

, , ,

The blending of the noise contribution from the four corners is performed in a manner similar

to bilinear interpolation, using the fifth order blending curve to compute the interpolant:

The result is the final value of the noise function for the point . In 3D, the gradients

are three-dimensional and the interpolation is performed along three axes, one at a time. I do not

present details here, but you can find it in the code examples at the end of this document.

Generalization can be made to an arbitrary number of dimensions.

Picking the gradients

For the noise function to be repeatable, i.e. always yield the same value for a given input point,

gradients need to be pseudo-random, not truly random. They need to have enough variation to

conceal the fact that the function is not truly random, but too much variation will cause unpre-

dictable behaviour for the noise function. A good choice for 2D and higher is to pick gradients

of unit length but different directions. For 2D, 8 or 16 gradients distributed around the unit circle

is a good choice. For 3D, Ken Perlin’s recommended set of gradients is the midpoints of each

of the 12 edges of a cube centered on the origin.

For 4D, a suitable set of gradients is the midpoints of each of the 32 edges of a 4D hypercube:

, ,

, , , ,

, , ,

uxi–= vyj–=

•=

u 1–

•=

v 1–

•=

u 1–

v 1–

•=

t() 6t

15t

–10t

fu() n

1 fu()–()+= n

fu() n

1 fu()–()+=

fv() n

1 fv()–()+=

xy,()

011,,()= g

01 1–,,()=

01–1,,()= g

01–1–,,()=

101,,()= g

10 1–,,()=

1–01,,()= g

1–01–,,()=

110,,()= g

11–0,,()=

1–10,,()= g

1–1–0,,()=

0111,,,()= g

011 1–,,,()= g

01 1–1,, ,()= g

01 1–1–,, ,()=

01–11,,,()= g

01–11–,,,()= g

01–1–1,,,()= g

01–1–1–,,,()=

1011,,,()= g

101 1–,,,()= g

10 1–1,, ,()= g

10 1–1–,, ,()=

1– 011,,,()= g

1–011–,,,()= g

1–01–1,, ,()= g

1–01–1–,, ,()=

1101,,,()= g

110 1–,,,()= g

11–01,,,()= g

11–01–,,,()=

1– 101,,,()= g

1–101–,,,()= g

1–1–01,,,()= g

1–1–01–,,,()=

1110,,,()= g

11 1–0,, ,()= g

11–10,,,()= g

11–1–0,,,()=

1– 110,,,()= g

1–11–0,, ,()= g

1–1–10,,,()= g

1–1–1–0,,,()=

(1-f()) and f() should be

swapped in these three

equations. My bad.

It really doesn’t matter very much exactly which gradients are picked, as long as they are not

too few and are reasonably evenly distributed over all directions. Gradients with values of only

, and for each component are chosen because taking a dot product with such a vector

does not require any multiplications, only additions and subtractions.

To associate each grid point with exactly one gradient, the integer coordinates of the point can

be used to compute a hash value, which in turn can be used as the index into a look-up table of

the gradients.

This concludes my presentation of classic Perlin noise.

Simplex grids

Simplex grids, or simplical tesselation of N-space, sounds fancy and is a bit hard to grasp, but

what it boils down to is quite simple: for a space with dimensions, pick the simplest and most

compact shape that can be repeated to fill the entire space. For a one-dimensional space, the sim-

plest (in fact, the only possible) space-filling shape is intervals of equal length placed one after

another, head to tail. In two dimensions, the obvious choice for a space-filling shape is a square,

but that shape has more corners than what is necessary. The simplest shape that tiles a 2D plane

is a triangle, and the formal simplex shape in 2D is an equilateral triangle. Two of these make a

rhombus, a shape that can be thought of as a square that has been squashed along its main diag-

onal.

In three dimensions, the simplex shape is a slightly skewed tetrahedron, six of which make a

cube that has been squashed along its main diagonal.

In four dimensions, the simplex shape is very hard to visualize, but it has five corners, and 24

of these shapes make a 4D hypercube that has been squashed along its main diagonal. Generally

speaking, the simplex shape for dimensions is a shape with corners, and of these

shapes can fill an N-dimensional hypercube that has been squashed along its main diagonal.

The definite advantage of a simplex shape is that it has as few corners as possible, much fewer

corners than a hypercube. This makes it easier to interpolate values in the interior of the simplex

based on the values at its corners. While a hypercube in dimensions has corners, a sim-

01 1–

NN1+ N!

N 2

plex in dimensions has only corners. As we move to higher dimensions, the complex-

ity of evaluating a function at each corner of a hypercube and interpolating along each principal

axis is an problem that quickly becomes intractable, while a similar evaluation for each

corner of a simplex shape followed by interpolation presents a much less daunting computation-

al task of complexity .

Moving from interpolation to summation

A fundamental problem of classic noise is that it involves sequential interpolations along each

dimension. Apart from the rapid increase in computational complexity as we move to higher di-

mensions, it becomes more and more of a problem to compute the analytic derivative of the in-

terpolated function. Simplex noise instead uses a straight summation of contributions from each

corner, where the contribution is a multiplication of the extrapolation of the gradient ramp and

a radially symmetric attenuation function. In signal processing terms, this is a signal reconstruc-

tion kernel. The radial attenuation is carefully chosen so that the influence from each corner

reaches zero before crossing the boundary to the next simplex. This means that points inside a

simplex will only be influenced by the contributions from the corners of that particular simplex.

For 2D, the influence from each corner can be visualized as a small wiggle function (Ken Perlin

uses the term “surflet”) around the corner point, with any point on the surface having at most

three non-zero parts of a wiggle covering it.

Selecting and traversing a simplex

The final trick to making a simplex noise algorithm work is to decide which simplex you are in

for any point in space. This is most easily performed in two steps. First you skew the input co-

ordinate space along the main diagonal so that each squashed hypercube of simplices trans-

forms to a regular, axis-aligned N-dimensional hypercube. Then you can easily decide which

hypercube you are in by taking the integer part of the coordinates for each dimension, similarly

to classic noise. Then, the further decision on which particular simplex the point is in can be

made by comparing the magnitudes of the distances in each dimension from the hypercube or-

igin to the point in question. Figures make this a lot more clear.

A point P inside a simplex gets contributions to its

value only from the three kernels centered on the

surrounding corners (shaded, red circles). Kernels at

corners farther away (green circles) decay to zero

before they cross the boundary to the simplex con-

taining P. Thus, the noise value at each point can

always be calculated as a sum of three terms.

NN1+

O 2

()

ON()

++ =

N^2, actually.

评论收藏

内容反馈

Dave66666666

粉丝: 4
资源: 21

柏林噪声和改进版噪声源码和实现思路 Perlin Noise && Simplex Noise

评论0

最新资源

柏林噪声和改进版噪声源码和实现思路 Perlin Noise && Simplex Noise

评论0

Perlin Noise柏林噪声生成2d深度图高程图Python代码

这是一个干净、快速、现代且免费的 Perlin Simplex 噪声函数_ C++_代码_下载

perlin noise 柏林噪声

Perlin噪声1D&2D代码

柏林噪声生成

perlin noise 柏林噪声例子

cv_perlin_noise:用于 OpenCV 的柏林噪声图像生成器

Unity 创建柏林(Perlin)噪声图：PerlinGenerateMap.unitypackage

生成柏林噪声纹理的程序

Perlin Noise Delphi版本

Perlin噪声1D&2D&3D&D代码

Python库 | perlin_noise-1.12.tar.gz

Unity实现的Perlin噪声插件源码

2d perlin noise ocean

perlin_noise:Rust中简单的Perlin噪声实现

柏林噪声perlin nosie.zip

perlin_noise_flowfields:使用perlin杂讯和流场创建漂亮的图片

Perlin-Noise-3D-Voxel生成器：基于perlin 3d噪声的体素生成器| Python OpenGL

论文研究-基于Perlin噪声的海面仿真在VegaPrime中的应用.pdf

PerlinNoise

PerlinNoise:Perlin噪声算法的实现

perlin-noise:一个简单的实现一个柏林噪声函数用于创建虚拟数据

Unity 米哈游原神三渲二Shader

数字孪生+unity+机械臂控制

Unity跑酷小游戏源工程

【数字孪生】机械臂虚拟控制unity demo

导出FBX0.1.unitypackage

Unity插件 140个天空盒分享

Unity游戏项目-3D迷宫(免费)

最新资源