Median filter

Median filter
The median filter is a non-linear digital filtering technique, often used to remove noise from an image or signal. Such noise reduction is a typical pre-processing step to improve the results of later processing (for example, edge detection on an image). Median filtering is very widely used in digital image processing because, under certain conditions, it preserves edges while removing noise (but see the discussion below), also having applications in signal processing.
Algorithm description
The main idea of the median filter is to run through the signal entry by entry, replacing each entry with the median of neighboring entries. The pattern of neighbors is called the "window", which slides, entry by entry, over the entire signal. For one-dimensional signals, the most obvious window is just the first few preceding and following entries, whereas for two-dimensional (or higher-dimensional) data the window must include all entries within a given radius or ellipsoidal region (i.e. the median filter is not a separable filter).
Worked one-dimensional example
To demonstrate, using a window size of three with one entry immediately preceding and following each entry, a median filter will be applied to the following simple one-dimensional signal:
x = (2, 3, 80, 6, 2, 3).
So, the median filtered output signal y will be:
y1 = med(2, 3, 80) = 3, (already 2, 3, and 80 are in the increasing order so no need to arrange them)
y2 = med(3, 80, 6) = med(3, 6, 80) = 6, (3, 80, and 6 are rearranged to find the median)
y3 = med(80, 6, 2) = med(2, 6, 80) = 6,
y4 = med(6, 2, 3) = med(2, 3, 6) = 3,
i.e. y = (3, 6, 6, 3).
Boundary issues
When implementing a median filter, the boundaries of the signal must be handled with special care, as there are not enough entries to fill an entire window. There are several schemes that have different properties that might be preferred in particular circumstances:
When calculating the median of a value near the boundary, missing values are filled by repeating the boundary value to obtain enough entries to fill the window.
Avoid processing the boundaries, with or without cropping the signal or image boundary afterwards,
Fetching entries from other places in the signal. With images for example, entries from the far horizontal or vertical boundary might be selected,
Shrinking the window near the boundaries, so that every window is full.
Two-dimensional median filter pseudo code
Code for a simple two-dimensional median filter algorithm might look like this:
1. allocate outputPixelValue[image width][image height]
2. allocate window[window width × window height]
3. edgex := (window width / 2) rounded down
4. edgey := (window height / 2) rounded down
for x from edgex to image width - edgex do
for y from edgey to image height - edgey do
i = 0
for fx from 0 to window width do
for fy from 0 to window height do
window[i] := inputPixelValue[x + fx - edgex][y + fy - edgey]
i := i + 1
sort entries in window[]
outputPixelValue[x][y] := window[window width * window height / 2]
This algorithm:
Processes one color channel only,
Takes the "not processing boundaries" approach (see above discussion about boundary issues).
Algorithm implementation issues
Typically, by far the majority of the computational effort and time is spent on calculating the median of each window. Because the filter must process every entry in the signal, for large signals such as images, the efficiency of this median calculation is a critical factor in determining how fast the algorithm can run. The naïve implementation described above sorts every entry in the window to find the median; however, since only the middle value in a list of numbers is required, selection algorithms can be much more efficient. Furthermore, some types of signals (very often the case for images) use whole number representations: in these cases, histogram medians can be far more efficient because it is simple to update the histogram from window to window, and finding the median of a histogram is not particularly onerous.
Edge preservation properties
Median filtering is one kind of smoothing technique, as is linear Gaussian filtering. All smoothing techniques are effective at removing noise in smooth patches or smooth regions of a signal, but adversely affect edges. Often though, at the same time as reducing the noise in a signal, it is important to preserve the edges. Edges are of critical importance to the visual appearance of images, for example. For small to moderate levels of Gaussian noise, the median filter is demonstrably better than Gaussian blur at removing noise whilst preserving edges for a given, fixed window size. However, its performance is not that much better than Gaussian blur for high levels of noise, whereas, for speckle noise and salt-and-pepper noise (impulsive noise), it is particularly effective. Because of this, median filtering is very widely used in digital image processing.
See also
Edge-preserving filtering
Image noise
Weighted median
pseudo-median filter
Lulu smoothing
Bilateral filter
Average with limited data validity
Smoothing
References
External links
Fast MATLAB one-dimensional median filter implementation
Mathematica MedianFilter function
Median filter
Fast two-dimensional median filter
Implementation of two-dimensional median filter in constant time (GPL license) – the running time per pixel of this algorithm is proportional to the number of elements in a histogram (typically this is , where n is the number of bits per channel), even though this in turn is a constant.
Implementation written in different programming languages (on Rosetta Code)
Dr Dobbs article
100+ Times Faster Weighted Median Filter
Circle median filter Median filter for circle-valued data such as phase or orientation images (C++/Matlab)
Nonlinear filters
Signal processing
Image noise reduction techniques
Articles with example pseudocode