# Generate white noise in 2D

## Update:

Just for fun, here's the process I think you were trying to implement. Wikipedia suggested to me that it was called pink noise, so we'll use pink names.

pinkify =
Compile[
{{data, _Complex, 2}, {center, _Real, 1}, {p, _Real}},
MapIndexed[
#/(Norm[#2 - center]^p) &,
data,
{2}
]
];
pinkNoiseTransform[
data : {{__}, ___},
center : {_?NumericQ, _?NumericQ} | Automatic : Automatic,
p : _?NumericQ : 1,
fn : Except[_?NumericQ] : Abs
] :=
Map[
fn,
InverseFourier@
pinkify[Fourier[data],
If[IntegerQ[#], # + .8, #] & /@
Replace[center, Automatic :> Dimensions[data]/2],
p
],
{2}
];
pinkNoiseTransform[i : _Integer | {_Integer, _Integer}, r___] :=

pinkNoiseTransform[whiteNoise2D[i], r]


I think the center point we assign minus the position in the matrix is f, so that's what I'm using 1/f.

Here's an example:

dims = {100, 100};
data = whiteNoise2D[dims];
centralFrequency = dims/2;
power = 1.8;
pinky = pinkNoiseTransform[data, centralFrequency, power, Norm];

Image[
Rescale[pinky, MinMax[pinky], {1, 0}],
ColorSpace -> "Grayscale",
ImageSize -> {300, 300},
Interleaving -> True
] One cool thing is that we can use the Re and Im parts of our data as different channels:

rePink =
pinkNoiseTransform[data, centralFrequency, power, Re];
imPink =
pinkNoiseTransform[data, centralFrequency, power, Im];

Image[
List,
{
Rescale[pinky, {0, 1}, {1, 0}],
Rescale[rePink, {0, 1}, {1, 0}],
Rescale[imPink, {0, 1}, {1, 0}]
},
2],
ColorSpace -> "RGB",
ImageSize -> {300, 300},
Interleaving -> True
] Finally, here's some 3D terrain from a smaller version of this (note that anything except PerformanceGoal->"Speed" gives too jagged as surface):

terrain =
Join @@
MapIndexed[
Append[#2, #] &,
pinkNoiseTransform[350, centralFrequency, power],
{2}
];

ListPlot3D[terrain,
ColorFunction -> "GreenBrownTerrain",
PerformanceGoal -> "Speed"
] I think you've got the wrong idea about what it's generating. The 2 simply means do 2 traces.

Try this:

whiteNoise2D[n_Integer] :=
whiteNoise2D[{n, n}];
whiteNoise2D[{n_, m_}] :=

RandomFunction[WhiteNoiseProcess[], {0, n}, m]["ValueList"];
whiteNoiseImage[{n_, m_}, size_: Automatic] :=

Image[whiteNoise2D[{n, m}],
ImageSize -> Replace[size, Automatic :> {n, m}]
]

Image[Rescale[whiteNoise2D[{500, 500}]],
ImageSize -> {250, 250}] We can use RandomVariate like this to generate white noise:

RandomVariate[UniformDistribution[], {256, 256}] // Image RandomVariate[NormalDistribution[], {256, 256}] // Image To just get the image, there is also RandomImage:

RandomImage[] RandomImage[NormalDistribution[]] The underlying data can be retrieved using ImageData.

The 3D visualization in the screenshot in the question is the same underlying data visualized with a ListPlot3D like function:

ListPlot3D[
RandomVariate[UniformDistribution[], {256, 256}],
ColorFunction -> GrayLevel
] ListPlot3D[
RandomVariate[NormalDistribution[], {256, 256}],
ColorFunction -> GrayLevel
] 