Noise

Posted on | In
Noise fn.

https://catlikecoding.com/unity/tutorials/pseudorandom-noise/voronoi-noise/

Continuous

Perlin

v@noise = fit(noise(@P*chv('freq')-chv('offset')),.25,.75,0,1)*ch("amp");

Perlin - (0-1) non-zero centered result. (zero centered version better matches the ranges of the other noise fields)
Original Perlin - (-1, 1) marginally less efficient and with different characteristics than Perlin

Simplex

v@noise = xnoise(@P)

Simplex - (Faster than Perlin steep slopes) close to Perlin but samples on a simplex mesh rather than a grid. This results in less grid artifacts. It also uses a higher order bspline to provide better derivatives.

Sparse Convolution

v@noise = fit(snoise(
  @P*chv('freq')-chv('offset'),
  chi('turb'),
  ch('rough'),
  ch('atten')),-1,1,0,1)*ch("amp");

Sparse Convolution - (-1.7, 1.7) (clouds (above 0)) similar to Worley The noise returned is based on the weights of all of the closest points, with each point’s contribution based on a meta-ball like rolloff curve. That is, if the sample point is close to the sphere, its contribution will be greater. The bounds on the noise are roughly.

Discontinuous

Worley

Cell - wnoise(@P,seed,f1, f2, f3, f4); Computes 2D, anti-aliased cellular noise suitable for shading.
Worley - cwnoise(@P,seed,f1, f2, f3, f4); Computes 1D, 3D, and 4D Worley noise, which is synonymous with “cell noise”.
Voronoi - vnoise(@P,1,seed,f1, f2, v1, v2); Voronoi noise, which is similar to Worley noise but has additional control over jittering.

onoise similar to wnoise and vnoise. However, they are marginally less efficient in computation and don’t have the same characteristics.

v@noise = fit(onoise(
  @P*chv('freq')-chv('offset'),
  chi('turb'),
  ch('rough'),
  ch('atten')),-1,1,0,1)*ch("amp");

Bumps

v@noise = anoise(
  @P*freq - offset,
  turb,
  rough,
  atten) * amp;

Alligator - similar to Worley It is currently not possible to simulate Alligator noise using the Worley functions, but it is possible to get a very similar ‘look’. The bounds on the noise are roughly (0, 0.5) when turbulence is 0.

Jagged Square

Chebyshev -
Manhattan -
mwnoise(@P,seed,f1, f2, f3, f4);

Layered

Pyroclastic

Pyroclastic -mean: displacing a surface with a summed set of noise layers on different scales.

Detail

Turbulence - Turbulence (a loop to add successively finer amounts of the same noise for roughness)
Flow noise - The flow parameter can be thought of as an extra dimension, but a dimension whose period is always 1.

Fractal

  • Octaves - how many layers (high cost)
  • Lacunarity - How fast scale noise period (uv’s)
  • Roughness - Keep relativley low to be able ro control shape and not become random
Exponential distribution

A simple modification to the Perlin noise generator changing the gradient distribution in each octave to an exponential distribution results in realistic and interesting procedurally generated terrain.

Divergence free

Curl

Divergence free noise field is based on the cross product of the derivatives of two simplex noise functions. (vector operator that produces a scalar field)

v@perlin_curl_noise = curlnoise(@P*ch("noise_freq")-ch("noise_offset")) // perlin  

v@simplex_curl_noise = curlxnoise(@P*ch("noise_freq")-ch("noise_offset")) // simplex

VOP

Anti Alias noise (-0.5 - 0.5)

Perlin, Samplex
in 1/3/4D > out 1/3D
Faster than unified. Compute band-limited noise (shading)

  • 4D - You can append 4-th vector to Position and call it evolution. (anim offset without moving!) best in aaNoise

Anit Alias Flow noise

Similar to the Anti-Aliased Noise in 3/4D > out 1/3D
This type of noise is ideal for shading.

  • Flow parameter can be thought of as an extra dimension, but a dimension whose period is always 1.

Turbulence noise (0 - 1) (absolute value of anti-aliased noise)

Perlin, sparse Conv, Aligator, Samplex 1/3D
Turbulence Noise is generally Anti-Aliased Noise that is folded over and generally goes from 0 to 1.

Unified noise (0 - 1)

Slow and lot of options
Value noise, Perlin, Samplex, Worley
Presents a unified interface and uniform output range for all the noise types available in VEX

Cloud noise

samplex - with additional distortion on simplex & worley detials

Curl noise (3d - Vector)

Perlin, Sparse Conv, Aligator, Samplex
is non-divergent meaning that the noise has no “sinks” or “sources” and gives you a fluid-like.

![](/src/noise/HoudiniNoise.jpg)

COST NOISE - VEX
x Simplex   xnoise(@P)
1.0 Perlin   noise(@P)
1.0 Zero Centered Perlin    
1.0 Perlin Periodic   pnoise(@P,@period)
1.1 Original Perlin    
1.8 Worley   wnoise(@P,i@seed,f@f1,f@f2,f@f3,f@f4)
1.9 Voronoi   vnoise(@P,v@jitter,i@seed,f@f1,f@f2,v@pos1,v@pos2,v@period)
2.1 Sparse Convolution   snoise(@P, i@turbulence, f@rough, f@atten)
2.3 Alligator   anoise(@P, i@turbulence, f@rough, f@atten) 
vop_perlinNoiseVF(@P*chv("freq")-chv("off"),chi("turb"),ch("rg"),ch("att"))*ch("amp");  
vop_perlinNoiseVV(@P*chv("freq")-chv("off"),chi("turb"),ch("rg"'),ch("att"))*ch("amp");   

vop_simplexNoiseVF(@P*chv("freq")-chv("off"),chi("turb"),ch("rg"),ch("att"))*ch("amp");
vop_simplexNoiseVV(@P*chv("freq")-chv("off"),chi("turb"),ch("rg"),ch("att"))*ch("amp");

vop_correctperlinNoiseVF(@P*chv("freq")-chv("off"),chi("turb"),ch("rg"),ch("att"))*ch("amp");
vop_correctperlinNoiseVV(@P*chv("freq")-chv("off"),chi("turb"),ch("rg"),ch("att"))*ch("amp");

VEX

Random

f@rand_num = rand(@ptnum) - Creates a random number between 0 and 1 from a seed.
f@random_num = random(@P) - Generate a random number based on the position in 1-4D space.
f/v/p random_sobol(f/v/p seed, int offset) - more equal random distribution
f@Cd = chramp('Cd',rand(@ptnum)); - noise ramp

Animating noise

vector npos = v@P/1. + set(0., 666., 0.);   // Noise input 3D position
float namp = 1.;                            // namp (Noise amplitude)
float nval = 0.;                            // Init nval (Noise output value), and n
float nweight = 0.;                        //weight (Used to normalize octaves)
int oct = 9;                                // Number of Octaves
for( int i = 0; i < oct; i++ )    {
    float __nval = fit(abs(-0.5+noise(set(npos.x,npos.y,npos.z,f@Time))), 0.0, 0.1, 1., 0.);
    nval += __nval * namp;                  // Amplitude
    nweight += namp;                        // Accumulate weight
    npos *= 2.132433;                       // Lacunarity
    namp *= 0.666;                          // Roughness
}
v@Cd = 1 - pow(nval / nweight, 0.8765);     // Visualize Noise Output

https://mrkunz.com/blog/03-04-2017_Using-noise-in-VEX.html

Fade noise on curves with ramp

// Requires uvtexture SOP in "Pts and Columns" mode before this wrangle

// Define UI controls
float remap_uv = chramp('remap_uv', @uv.x);
float power = chf('Noise_Power');
float freq = chf('Noise_Frequency');

// Create noise
vector noiseXYZ = noise(@P*freq);
// Modify noise values
vector displace = fit(noiseXYZ, 0,1, -1, 1)*power*remap_uv;
// Apply modified noise to a points position
@P += displace;
// Visualize fade ramp on curve
@Cd = remap_uv;

Delete Points based on noise


// Visualise nose as Black and White values
// Delete black and white points separatly

// Default non zero values for 10X10 grid:
// Noise_size = 1
// Noise_threshold = 0.5

// Make geometry white
@Cd = {1, 1, 1};

// Setup noise
float noseValues = noise(@P*(1/chf('Noise_Size')) + chf('Noise_Offset'));

// Paint-delete points with noise
if(noseValues > chf('Noise_Threshold')){
    @Cd = 0;
    if(rand(@ptnum) < ch('delete_black')){
        if(chi('del') == 0){
            @Cd = {1,0,0};
            }
        else{
            removepoint(0,@ptnum);
            }
        }
    }

if(noseValues < chf('Noise_Threshold')){
    if ( rand(@ptnum) < ch('delete_white') ) {       
        if(chi('del') == 0){
            @Cd = {1,0,0};
            }
        else{
            removepoint(0,@ptnum);
            }
        }
    }

https://www.nekopori.com/blog/houdini-noisesample
https://adrianb.io/2014/08/09/perlinnoise.html https://sighack.com/post/getting-creative-with-perlin-noise-fields