### How To Make Gaussian Noise On Image – C# Guide

Gaussian noise on images is generated with Gaussian probability distribution function. It simulates noise that appears in practice.

Filter by Category

- C# Tutorial(85)
- C# Image Processing(69)
- Morphological Processes(20)
- Image Processing(16)
- Image Restoration and Reconstruction(16)
- Image Segmentation(13)
- C# Data Structures And Algorithms(11)
- Color Image Processing(8)
- Frequency Domain Filtering(8)
- Image Noise(6)
- Grayscale Morphology(5)
- Thresholding(4)
- Order-Statistic Filters(4)
- Mean Filters(4)
- Sorting Algorithms(4)
- Morphological Reconstruction(3)
- Edge Detection(3)
- Simple Lists(2)
- RGB to HSI Color Model(2)
- Adaptive Filters(2)
- Tone and Color Corrections(2)
- Linked Lists(2)
- Stacks(1)
- Queues(1)
- Point Detection(1)
- Line Detection(1)
- C# Arrays(1)
- Region Segmentation Using Superpixels(1)
- Region Segmentation With K Means Clustering(1)
- Region Splitting And Merging(1)
- Sorted Lists(1)
- Region Growing Segmentation(1)
- Digital Image Watermarking(1)
- Using Color In Image Segmentation(1)
- Social Games(1)
- Bandreject Filters(1)
- Bandpass filters(1)
- Notch Filters(1)
- Landing Pages(1)
- Intensity Slicing and Color Coding(1)
- Color Slicing(1)
- Histogram Processing Color Images(1)
- Color Image Smoothing And Sharpening(1)
- C# Basics(1)

Back to Latest Articles
###
How To Make Gaussian Noise On Image – C# Guide

###
How To Use Notch Filters – C# Guide

###
How To Use Bandpass Filters – C# Guide

###
How To Use Bandreject Filters – C# Guide

###
How To Use Laplacian Filter – C# Guide

###
How To Use Gaussian Highpass Filter – C# Guide

###
How To Use Butterworth Highpass Filter – C# Guide

###
How To Use Ideal Highpass Filter – C# Guide

###
How To Use Gaussian Lowpass Filter – C# Guide

###
How To Use Butterworth Lowpass Filter – C# Guide

Image Noise

Gaussian noise on images is generated with Gaussian probability distribution function. It simulates noise that appears in practice.

Frequency Domain Filtering

We can use notch filters for attenuating frequencies on custom locations across the frequency map. But for that we will need to utilize all of the knowledge we’ve acquired...

Frequency Domain Filtering

Bandpass filters are the counterpart of bandreject filters. Therefore, they attenuate every frequency outside the ring. In case you’re just tuning in, let me clarify what I...

Frequency Domain Filtering

We use bandreject filters to attenuate a ring of frequencies around the center of a 2 dimensional frequency map. Now what does all that mean? We’re going to focus on...

Frequency Domain Filtering

We use Laplacian filter to sharpen images. We are going to talk about the details how exactly this filter works. In essence, it’s one of the highpass filters, which...

C# Tutorial

Gaussian highpass filter processes images in frequency domain. It attenuates low frequencies without creating ringing artifacts.

C# Tutorial

Butterworth highpass filter is used to filter images in frequency domain. We can control how smooth transition beyond cut off frequency.

C# Tutorial

Ideal highpass filter is used to filter images in the frequency domain. It attenuates low frequencies and keeps high frequencies.

C# Tutorial

We’ve talked about ideal lowpass filter and Butterworth lowpass filter already. And now, we shall get to know the last type of lowpass filters, which is Gaussian lowpass...

C# Image Processing

Butterworth lowpass filter is used to modify images in the frequency domain.

How To Make Gaussian Noise On Image –...

Gaussian noise is a great approximation to noise we get from taking a photo. In other words, our sensoring equipment is sometimes affected by a veriety of factors. These are usually the quality of equipment and environmental conditions.

For instance, a charged coupled device – camera is sensitive to light levels and temperature changes. These affect the quality of photos the most. But they aren’t the only reason why we could get a corrupted image.

Our images can also get corrupted in the transmission. Most commonly when we’re transmitting wirelessly, where lightning and other atmospheric disturbances can physically influence our signal.

When we gather a large amount of data about a certain event or events in nature, we can often see the pattern of Gaussian distribution. We also call it normal distribution and we’re going to use it to calculate random values for our Gaussian noise.

The following formula is our Gaussian probability distribution function.

If we look at the formula there are 3 unknown varibales, which are *σ (sigma)*, *y* and *μ (mi)*. Sigma and mi represent standard deviation and mean which affect the position and width of distributed values.

As you can see from the formula that we use standard deviation to the power of 2, which is variance of the distribution. The only unknown we haven’t explained yet is *y*, which is our random variable. Therefore, we need to generate this number with random number generator class.

I feel we should also mention, that the sum of all calculated values in the distribution curve equals to 1. Therefore, we will also need to bring those values to displayable range for our image noise.

We can do that with formula for feature scaling which we already used before in tutorial for Laplacian filter in frequency domain.

Once we generate Gaussian noise, we need to apply it to our image. We can do that by summing the image pixel values with generated noise value.

I wrote an extension function that takes our original image as input and adds noise to it and outputs the final result.

```
public static Bitmap GaussianNoise(this Bitmap image)
{
int w = image.Width;
int h = image.Height;
```` BitmapData image_data = image.LockBits(`

` new Rectangle(0, 0, w, h),`

` ImageLockMode.ReadOnly,`

` PixelFormat.Format24bppRgb);`

` int bytes = image_data.Stride * image_data.Height;`

` byte[] buffer = new byte[bytes];`

` byte[] result = new byte[bytes];`

` Marshal.Copy(image_data.Scan0, buffer, 0, bytes);`

` image.UnlockBits(image_data);`

` byte[] noise = new byte[bytes];`

` double[] gaussian = new double[256];`

` int std = 20;`

` Random rnd = new Random();`

` double sum = 0;`

` for (int i = 0; i < 256; i++)`

` {`

` gaussian[i] = (double)((1 / (Math.Sqrt(2 * Math.PI) * std)) * Math.Exp(-Math.Pow(i, 2) / (2 * Math.Pow(std, 2))));`

` sum += gaussian[i];`

` }`

` for (int i = 0; i < 256; i++)`

` {`

` gaussian[i] /= sum;`

` gaussian[i] *= bytes;`

` gaussian[i] = (int)Math.Floor(gaussian[i]);`

` }`

` int count = 0;`

` for (int i = 0; i < 256; i++)`

` {`

` for (int j = 0; j < (int)gaussian[i]; j++)`

` {`

` noise[j + count] = (byte)i;`

` }`

` count += (int)gaussian[i];`

` }`

` for (int i = 0; i < bytes - count; i++)`

` {`

` noise[count + i] = 0;`

` }`

` noise = noise.OrderBy(x => rnd.Next()).ToArray();`

` for (int i = 0; i < bytes; i++)`

` {`

` result[i] = (byte)(buffer[i] + noise[i]);`

` }`

` Bitmap result_image = new Bitmap(w, h);`

` BitmapData result_data = result_image.LockBits(`

` new Rectangle(0, 0, w, h),`

` ImageLockMode.WriteOnly,`

` PixelFormat.Format24bppRgb);`

` Marshal.Copy(result, 0, result_data.Scan0, bytes);`

` result_image.UnlockBits(result_data);`

` return result_image;`

` }`

Gaussian noise is one of the most tractable noise distribution models we use in practice. In other words, it’s very useful for simulating real life data of certain events like random noise on images, or other signals.

You can also download the project for free and examine the code yourself.