# Something More for Research

• ## Follow Blog via Email

Join 5,056 other followers

• ## Blog Stats

• 167,664 hits

# Alpha-trimmed mean filter

Category. Digital signal and image processing (DSP and DIP) software development.

Abstract. The article is a practical tutorial for alpha-trimmed mean filter understanding and implementation. Article contains theory, C++ source code, programming instructions and sample applications.

## 1. Introduction to alpha-trimmed mean filter

Alpha-trimmed mean filter is windowed filter of nonlinear class, by its nature is hybrid of the mean and median filters. The basic idea behind filter is for any element of the signal (image) look at its neighborhood, discard the most atypical elements and calculate mean value using the rest of them. Alpha you can see in the name of the filter is indeed parameter responsible for the number of trimmed elements.

## 2. Understanding alpha-trimmed mean filter

Now let us see, how to get alpha-trimmed mean value in practice. The basic idea here is to order elements, discard elements at the beginning and at the end of the got ordered set and then calculate average value using the rest. For instance, let us calculate alpha-trimmed mean for the case, depicted in fig. 1.

Fig. 1. Alpha-trimmed mean calculation.

Thus, to get an alpha-trimmed mean we are to order elements, eliminate elements at the beginning and at the end of the got sequenced collection and get average of the remaining elements. That is all — now alpha-trimmed mean calculated and signal, 1D in our case, filtered by alpha-trimmed mean filter! Let us make resume and write down step-by-step instructions for processing by alpha-trimmed mean filter.

Alpha-trimmed mean filter algorithm:

1. Place a window over element;
2. Pick up elements;
3. Order elements;
4. Discard elements at the beginning and at the end of the got ordered set;
5. Take an average — sum up the remaining elements and divide the sum by their number.

A couple of words about alpha parameter responsible for trimmed elements. In practice alpha is the number of elements to be discarded, for instance, in our case alpha is two. Since our filter is symmetric one alpha is an even nonnegative number less than size of the filter window. Minimum value for alpha parameter is zero and in this case alpha-trimmed mean filter degenerates into mean filter. Maximum value for alpha is filter window size minus one and in this case filter degenerates into median filter.

Now, when we have the algorithm, it is time to write some code — let us come down to programming.

## 3. 1D alpha-trimmed mean filter programming

In this section we develop 1D alpha-trimmed mean filter with window of size 5. Let us have 1D signal of length N as input. The first step is window placing — we do that by changing index of the leading element:

``````//   Move window through all elements of the signal
for (int i = 2; i < N - 2; ++i)``````

Pay attention, that we are starting with the third element and finishing with the last but two. The problem is we cannot start with the first element, because in this case the left part of the filter window is empty. We will discuss below, how to solve that problem.

The second step is picking up elements around, ok:

``````//   Pick up window elements
for (int j = 0; j < 5; ++j)
window[j] = signal[i - 2 + j];``````

The third step is putting window elements in order. But we will use a code optimization trick here. As soon as we need only middle part of the ordered set we can omit putting in order last α/2 elements. So, it is enough to process just 5-α/2 elements:

``````//   End of the trimmed ordered set
const int end = 5 - (alpha >> 1);``````

Now:

``````//   Order elements (only necessary part of them)
for (int j = 0; j < end; ++j)
{
//   Find position of minimum element
int min = j;
for (int k = j + 1; k < 5; ++k)
if (window[k] < window[min])
min = k;
//   Put found minimum element in its place
const element temp = window[j];
window[j] = window[min];
window[min] = temp;
}``````

To discard elements at the beginning of the ordered set let us define the proper constant:

``````//   Start of the trimmed ordered set
const int start = alpha >> 1;``````

The final step — taking the average:

``````//   Get result - the mean value of the elements in trimmed set
result[i - 2] = window[start];
for (int j = start + 1; j < end; ++j)
result[i - 2] += window[j];
result[i - 2] /= N - alpha;``````

At last, let us write down the entire algorithm as function:

``````//   1D ALPHA-TRIMMED MEAN FILTER implementation
//     signal - input signal
//     result - output signal
//     N      - length of the signal
//     alpha  - filter alpha parameter
void _alphatrimmedmeanfilter(const element* signal, element* result,
int N, int alpha)
{
//   Start of the trimmed ordered set
const int start = alpha >> 1;
//   End of the trimmed ordered set
const int end = 5 - (alpha >> 1);
//   Move window through all elements of the signal
for (int i = 2; i < N - 2; ++i)
{
//   Pick up window elements
element window[5];
for (int j = 0; j < 5; ++j)
window[j] = signal[i - 2 + j];
//   Order elements (only necessary part of them)
for (int j = 0; j < end; ++j)
{
//   Find position of minimum element
int min = j;
for (int k = j + 1; k < 5; ++k)
if (window[k] < window[min])
min = k;
//   Put found minimum element in its place
const element temp = window[j];
window[j] = window[min];
window[min] = temp;
}
//   Get result - the mean value of the elements in trimmed set
result[i - 2] = window[start];
for (int j = start + 1; j < end; ++j)
result[i - 2] += window[j];
result[i - 2] /= 5 - alpha;
}
}``````

Type `element` could be defined as:

``typedef double element;``

## 4. Treating edges

For all window filters there is some problem. That is edge treating. If you place window over first (last) element, the left (right) part of the window will be empty. To fill the gap, signal should be extended. For alpha-trimmed mean filter there is good idea to extend signal symmetrically, like this:

Fig. 2. Signal extension.

So, before passing signal to our alpha-trimmed mean filter function the signal should be extended. Let us write down the wrapper, that makes all preparations.

``````//   1D ALPHA-TRIMMED MEAN FILTER wrapper
//     signal - input signal
//     result - output signal
//     N      - length of the signal
//     alpha  - filter alpha parameter
void alphatrimmedmeanfilter(element* signal, element* result, int N, int alpha)
{
//   Check arguments
if (!signal || N < 1 || alpha < 0 || 4 < alpha || alpha & 1)
return;
//   Treat special case N = 1
if (N == 1)
{
if (result)
result[0] = signal[0];
return;
}
//   Allocate memory for signal extension
element* extension = new element[N + 4];
//   Check memory allocation
if (!extension)
return;
//   Create signal extension
memcpy(extension + 2, signal, N * sizeof(element));
for (int i = 0; i < 2; ++i)
{
extension[i] = signal[1 - i];
extension[N + 2 + i] = signal[N - 1 - i];
}
//   Call alpha-trimmed mean filter implementation
_alphatrimmedmeanfilter(extension + 2, result ? result : signal,
N + 4, alpha);
//   Free memory
delete[] extension;
}``````

As you can see, our code takes into account some practical issues. First of all we check our input parameters — signal should not be NULL, signal length should be positive, alpha parameter should be even nonnegative number less than window size:

``````//   Check arguments
if (!signal || N < 1 || alpha < 0 || 4 < alpha || alpha & 1)
return;``````

Second step — we check case N=1. This case is special one, because to build extension we need at least two elements. For the signal of 1 element length the result is the signal itself. As well pay attention, our alpha-trimmed mean filter works in-place, if output parameter `result`is NULL.

``````//   Treat special case N = 1
if (N == 1)
{
if (result)
result[0] = signal[0];
return;
}``````

Now let us allocate memory for signal extension.

``````//   Allocate memory for signal extension
element* extension = new element[N + 4];``````

And check memory allocation.

``````//   Check memory allocation
if (!extension)
return;``````

Now we are building extension.

``````//   Create signal extension
memcpy(extension + 2, signal, N * sizeof(element));
for (int i = 0; i < 2; ++i)
{
extension[i] = signal[1 - i];
extension[N + 2 + i] = signal[N - 1 - i];
}``````

Finally, everything is ready — filtering!

``````//   Call alpha-trimmed mean filter implementation
_alphatrimmedmeanfilter(extension, result ? result : signal, N + 4, alpha);``````

And to complete the job — free memory.

``````//   Free memory
delete[] extension;``````

Since we are using memory management function from standard library, we should include its header.

``#include <memory.h>``

## 5. 2D alpha-trimmed mean filter programming

In 2D case we have 2D signal, or image. The idea is the same, just now alpha-trimmed mean filter has 2D window. Window influences only the elements selection. All the rest is the same: ordering elements, trimming the got set and calculating average of the remaining elements. So, let us have a look at 2D alpha-trimmed mean filter programming. For 2D case we choose window of 3×3 size.

``````//   2D ALPHA-TRIMMED MEAN FILTER implementation
//     image  - input image
//     result - output image
//     N      - width of the image
//     M      - height of the image
//     alpha  - filter alpha parameter
void _alphatrimmedmeanfilter(const element* image, element* result,
int N, int M, int alpha)
{
//   Start of the trimmed ordered set
const int start = alpha >> 1;
//   End of the trimmed ordered set
const int end = 9 - (alpha >> 1);
//   Move window through all elements of the image
for (int m = 1; m < M - 1; ++m)
for (int n = 1; n < N - 1; ++n)
{
//   Pick up window elements
int k = 0;
element window[9];
for (int j = m - 1; j < m + 2; ++j)
for (int i = n - 1; i < n + 2; ++i)
window[k++] = image[j * N + i];
//   Order elements (only necessary part of them)
for (int j = 0; j < end; ++j)
{
//   Find position of minimum element
int min = j;
for (int l = j + 1; l < 9; ++l)
if (window[l] < window[min])
min = l;
//   Put found minimum element in its place
const element temp = window[j];
window[j] = window[min];
window[min] = temp;
}
//   Target index in result image
const int target = (m - 1) * (N - 2) + n - 1;
//   Get result - the mean value of the elements in trimmed set
result[target] = window[start];
for (int j = start + 1; j < end; ++j)
result[target] += window[j];
result[target] /= 9 - alpha;
}
}``````

## 6. Treating edges in 2D case

As for 1D case in 2D case we should extend our input image as well. To do that we are to add lines at the top and at the bottom of the image and add columns to the left and to the right.

Fig. 3. Image extension.

Here is our wrapper function, that does that job.

``````//   2D ALPHA-TRIMMED MEAN FILTER wrapper
//     image  - input image
//     result - output image
//     N      - width of the image
//     M      - height of the image
//     alpha  - filter alpha parameter
void alphatrimmedmeanfilter(element* image, element* result,
int N, int M, int alpha)
{
//   Check arguments
if (!image || N < 1 || M < 1 || alpha < 0 || 8 < alpha || alpha & 1)
return;
//   Allocate memory for signal extension
element* extension = new element[(N + 2) * (M + 2)];
//   Check memory allocation
if (!extension)
return;
//   Create image extension
for (int i = 0; i < M; ++i)
{
memcpy(extension + (N + 2) * (i + 1) + 1,
image + N * i,
N * sizeof(element));
extension[(N + 2) * (i + 1)] = image[N * i];
extension[(N + 2) * (i + 2) - 1] = image[N * (i + 1) - 1];
}
//   Fill first line of image extension
memcpy(extension, extension + N + 2, (N + 2) * sizeof(element));
//   Fill last line of image extension
memcpy(extension + (N + 2) * (M + 1),
extension + (N + 2) * M,
(N + 2) * sizeof(element));
//   Call alpha-trimmed mean filter implementation
_alphatrimmedmeanfilter(extension, result ? result : image,
N + 2, M + 2, alpha);
//   Free memory
delete[] extension;
}``````

## 7. Alpha-trimmed mean filter library

Now we have four functions, two of them are for processing 1D signals by alpha-trimmed mean filter, and other two are for filtering 2D images. It is time to put everything together and create small alpha-trimmed mean filter library. Let us write code for header file.

``````//   alphatrimmedmeanfilter.h - declarations for
//   1D and 2D alpha-trimmed mean filter routines
//
//   The code is property of LIBROW
//   You can use it on your own
//   When utilizing credit LIBROW site

#ifndef _ALPHATRIMMEDMEANFILTER_H_
#define _ALPHATRIMMEDMEANFILTER_H_

//   Signal/image element type
typedef double element;

//   1D ALPHA-TRIMMED MEAN FILTER, window size 5
//     signal - input signal
//     result - output signal, NULL for inplace processing
//     N      - length of the signal
//     alpha  - filter alpha parameter
void alphatrimmedmeanfilter(element* signal, element* result,
int N, int alpha);

//   2D ALPHA-TRIMMED MEAN FILTER, window size 3x3
//     image  - input image
//     result - output image, NULL for inplace processing
//     N      - width of the image
//     M      - height of the image
//     alpha  - filter alpha parameter
void alphatrimmedmeanfilter(element* image, element* result,
int N, int M, int alpha);

#endif``````

Our library is ready. The code we have written is good both for Linux/Unix and Windows platforms. You can download full alpha-trimmed mean filter library source code here:

Full listings of library files are available online as well:

And now — a couple of applications to play around!

## 8. Alpha-trimmed mean filter: image restoration

We have created a couple of applications to show alpha-trimmed mean filter capabilities in restoration images corrupted by impulse noise. The demo package includes 4 files — two applications, sample image and description:

• alphatrimmedmean.exe — alpha-trimmed mean filter,
• corrupter.exe — impulse noise generator,
• sample.bmp — 24-bit sample image,

Be aware of the fact, that this sample uses OpenGL, so it should be supported by your system (usually that is the case).

## 9. Step 1: prepare corrupted image

We have created impulse noise generator that will help us to prepare corrupted image. Start up corrupter.exe application and load image to be corrupted. Choose Set >> Corruption… or click N button in toolbar and set noise level at 5–15%. Click OK. Then save corrupted image.

Fig. 4. Corruption by impulse noise.

## 10. Step 2: restore corrupted image

Start up alphatrimmedmean.exe application. Load the saved corrupted image. Set alpha parameter to 6: Set >> Alpha… or click α button in toolbar and select 6 in dialog’s combo-box, click OK.

Fig. 5. Alpha parameter selection.

Apply alpha-trimmed mean filter by choosing Set >> Filter or clicking F-button in toolbar. See the result. If necessary, filter the image once more.

Fig. 6. Image restored by alpha-trimmed mean filter.

# Mean filter, or average filter

Category. Digital signal and image processing (DSP and DIP) software development.

Abstract. The article is a practical guide for mean filter, or average filter understanding and implementation. Article contains theory, C++ source code, programming instructions and sample application.

Reference. Adaptive averaging technique: Diffusion filter.

## 1. Introduction to mean filter, or average filter

Mean filter, or average filter is windowed filter of linear class, that smoothes signal (image). The filter works as low-pass one. The basic idea behind filter is for any element of the signal (image) take an average across its neighborhood. To understand how that is made in practice, let us start with window idea.

## 2. Filter window or mask

Let us imagine, you should read a letter and what you see in text restricted by hole in special stencil like this.

Fig. 1. First stencil.

So, the result of reading is sound [t]. Ok, let us read the letter again, but with the help of another stencil:

Fig. 2. Second stencil.

Now the result of reading t is sound [ð]. Let us make the third try:

Fig. 3. Third stencil.

Now you are reading letter t as sound [θ].

What happens here? To say that in mathematical language, you are making an operation (reading) over element (letter t). And the result (sound) depends on the element neighborhood (letters next to t).

And that stencil, which helps to pick up element neighborhood, is window! Yes, window is just a stencil or pattern, by means of which you are selecting the element neighborhood — a set of elements around the given one — to help you make decision. Another name for filter window is mask — mask is a stencil, which hides elements we are not paying attention to.

In our example the element we are operating on positioned at leftmost of the window, in practice however its usual position is the center of the window.

Let us see some window examples. In one dimension.

Fig. 4. Window or mask of size 5 in 1D.

In two dimensions.

Fig. 5. Window or mask of size 3×3 in 2D.

In three dimensions… Think about building. And now — about room in that building. The room is like 3D window, which cuts out some subspace from the entire space of the building. You can find 3D window in volume (voxel) image processing.

Fig. 6. Window or mask of size 3×3×3 in 3D.

## 3. Understanding mean filter

Now let us see, how to “take an average across element’s neighborhood”. The formula is simple — sum up elements and divide the sum by the number of elements. For instance, let us calculate an average for the case, depicted in fig. 7.

Fig. 7. Taking an average.

And that is all. Yes, we just have filtered 1D signal by mean filter! Let us make resume and write down step-by-step instructions for processing by mean filter.

Mean filter, or average filter algorithm:

1. Place a window over element;
2. Take an average — sum up elements and divide the sum by the number of elements.

Now, when we have the algorithm, it is time to write some code — let us come down to programming.

## 4. 1D mean filter programming

In this section we develop 1D mean filter with window of size 5. Let us have 1D signal of length N as input. The first step is window placing — we do that by changing index of the leading element:

``````//   Move window through all elements of the signal
for (int i = 2; i < N - 2; ++i)``````

Pay attention, that we are starting with the third element and finishing with the last but two. The problem is we cannot start with the first element, because in this case the left part of the filter window is empty. We will discuss below, how to solve that problem.

The second step is taking the average, ok:

``````//   Take the average
result[i - 2] = (
signal[i - 2] +
signal[i - 1] +
signal[i] +
signal[i + 1] +
signal[i + 2]) / 5;``````

Now, let us write down the algorithm as function:

``````//   1D MEAN FILTER implementation
//     signal - input signal
//     result - output signal
//     N      - length of the signal
void _meanfilter(const element* signal, element* result, int N)
{
//   Move window through all elements of the signal
for (int i = 2; i < N - 2; ++i)
//   Take the average
result[i - 2] = (
signal[i - 2] +
signal[i - 1] +
signal[i] +
signal[i + 1] +
signal[i + 2]) / 5;
}``````

Type `element` could be defined as:

``typedef double element;``

## 5. Treating edges

For all window filters there is some problem. That is edge treating. If you place window over first (last) element, the left (right) part of the window will be empty. To fill the gap, signal should be extended. For mean filter there is good idea to extend signal or image symmetrically, like this:

Fig. 8. Signal extension.

So, before passing signal to our mean filter function the signal should be extended. Let us write down the wrapper, which makes all preparations.

``````//   1D MEAN FILTER wrapper
//     signal - input signal
//     result - output signal
//     N      - length of the signal
void meanfilter(element* signal, element* result, int N)
{
//   Check arguments
if (!signal || N < 1)
return;
//   Treat special case N = 1
if (N == 1)
{
if (result)
result[0] = signal[0];
return;
}
//   Allocate memory for signal extension
element* extension = new element[N + 4];
//   Check memory allocation
if (!extension)
return;
//   Create signal extension
memcpy(extension + 2, signal, N * sizeof(element));
for (int i = 0; i < 2; ++i)
{
extension[i] = signal[1 - i];
extension[N + 2 + i] = signal[N - 1 - i];
}
//   Call mean filter implementation
_meanfilter(extension, result ? result : signal, N + 4);
//   Free memory
delete[] extension;
}``````

As you can see, our code takes into account some practical issues. First of all we check our input parameters — signal should not be NULL, and signal length should be positive:

``````//   Check arguments
if (!signal || N < 1)
return;``````

Second step — we check case N=1. This case is special one, because to build extension we need at least two elements. For the signal of 1 element length the result is the signal itself. As well pay attention, our mean filter works in-place, if output parameter `result` is NULL.

``````//   Treat special case N = 1
if (N == 1)
{
if (result)
result[0] = signal[0];
return;
}``````

Now let us allocate memory for signal extension.

``````//   Allocate memory for signal extension
element* extension = new element[N + 4];``````

And check memory allocation.

``````//   Check memory allocation
if (!extension)
return;``````

Now we are building extension.

``````//   Create signal extension
memcpy(extension + 2, signal, N * sizeof(element));
for (int i = 0; i < 2; ++i)
{
extension[i] = signal[1 - i];
extension[N + 2 + i] = signal[N - 1 - i];
}``````

Finally, everything is ready — filtering!

``````//   Call mean filter implementation
_meanfilter(extension, result ? result : signal, N + 4);``````

And to complete the job — free memory.

``````//   Free memory
delete[] extension;``````

Since we are using memory management function from standard library, we should include its header.

``#include <memory.h>``

## 6. 2D mean filter programming

In 2D case we have 2D signal, or image. The idea is the same, just now mean filter has 2D window. Window influences only the elements selection. The rest is the same: summing up the elements and dividing by their number. So, let us have a look at 2D mean filter programming. For 2D case we choose window of size 3×3.

``````//   2D MEAN FILTER implementation
//     image  - input image
//     result - output image
//     N      - width of the image
//     M      - height of the image
void _meanfilter(const element* image, element* result, int N, int M)
{
//   Move window through all elements of the image
for (int m = 1; m < M - 1; ++m)
for (int n = 1; n < N - 1; ++n)
//   Take the average
result[(m - 1) * (N - 2) + n - 1] = (
image[(m - 1) * N + n - 1] +
image[(m - 1) * N + n] +
image[(m - 1) * N + n + 1] +
image[m * N + n - 1] +
image[m * N + n] +
image[m * N + n + 1] +
image[(m + 1) * N + n - 1] +
image[(m + 1) * N + n] +
image[(m + 1) * N + n + 1]) / 9;
}``````

## 7. Treating edges in 2D case

As in 1D case in 2D case we should extend our input image as well. To do that we are to add lines at the top and at the bottom of the image and add columns to the left and to the right.

Fig. 9. Image extension.

Here is our wrapper function, which does that job.

``````//   2D MEAN FILTER wrapper
//     image  - input image
//     result - output image
//     N      - width of the image
//     M      - height of the image
void meanfilter(element* image, element* result, int N, int M)
{
//   Check arguments
if (!image || N < 1 || M < 1)
return;
//   Allocate memory for signal extension
element* extension = new element[(N + 2) * (M + 2)];
//   Check memory allocation
if (!extension)
return;
//   Create image extension
for (int i = 0; i < M; ++i)
{
memcpy(extension + (N + 2) * (i + 1) + 1,
image + N * i,
N * sizeof(element));
extension[(N + 2) * (i + 1)] = image[N * i];
extension[(N + 2) * (i + 2) - 1] = image[N * (i + 1) - 1];
}
//   Fill first line of image extension
memcpy(extension,
extension + N + 2,
(N + 2) * sizeof(element));
//   Fill last line of image extension
memcpy(extension + (N + 2) * (M + 1),
extension + (N + 2) * M,
(N + 2) * sizeof(element));
//   Call mean filter implementation
_meanfilter(extension, result ? result : image, N + 2, M + 2);
//   Free memory
delete[] extension;
}``````

## 8. Mean filter library

Now we have four functions, two of them are for processing 1D signals by mean filter, and other two are for filtering 2D images. It is time to put everything together and create small mean filter library. Let us write code for header file.

``````#ifndef _MEANFILTER_H_
#define _MEANFILTER_H_

//   Signal/image element type
typedef double element;

//   1D MEAN FILTER, window size 5
//     signal - input signal
//     result - output signal, NULL for inplace processing
//     N      - length of the signal
void meanfilter(element* signal, element* result, int N);

//   2D MEAN FILTER, window size 3x3
//     image  - input image
//     result - output image, NULL for inplace processing
//     N      - width of the image
//     M      - height of the image
void meanfilter(element* image, element* result, int N, int M);

#endif``````

Our library is ready. The code we have written is good both for Linux/Unix and Windows platforms. You can download full mean filter library source code here:

Full listings of library files are available online as well:

And now — an application to play around!

## 9. Color mean filter: image smoothing, or blurring

We have created an application to demonstrate mean filter properties. The sample package includes 3 files — the application, sample image and description:

• smoother.exe — mean filter,
• sample.bmp — 24-bit sample image,

Be aware of the fact, that this sample uses OpenGL, so it should be installed on your computer.

## 10. How to use

Start up smoother.exe application. Load the image.

Fig. 10. Original image.

Apply mean filter by choosing Set >> Filter or clicking F-button in toolbar. See the result. If necessary, filter the image one more time.

## Participate in Reproducible Research

### General Image Processing

OpenCV
(C/C++ code, BSD lic) Image manipulation, matrix manipulation, transforms
Torch3Vision
(C/C++ code, BSD lic) Basic image processing, matrix manipulation and feature extraction algorithms: rotation, flip, photometric normalisations (Histogram Equalization, Multiscale Retinex, Self-Quotient Image or Gross-Brajovic), edge detection, 2D DCT, 2D FFT, 2D Gabor, PCA to do Eigen-Faces, LDA to do Fisher-Faces. Various metrics (Euclidean, Mahanalobis, ChiSquare, NormalizeCorrelation, TangentDistance, …)
ImLab
(C/C++ code, MIT lic) A Free Experimental System for Image Processing (loading, transforms, filters, histogram, morphology, …)
CIMG
(C/C++ code, GPL and LGPL lic) CImg Library is an open source C++ toolkit for image processing
Generic Image Library (GIL)boost integration
(C/C++ code, MIT lic) Adobe open source C++ Generic Image Library (GIL)
SimpleCV a kinder, gentler machine vision library
(python code, MIT lic) SimpleCV is a Python interface to several powerful open source computer vision libraries in a single convenient package
PCL, The Point Cloud Library
(C/C++ code, BSD lic) The Point Cloud Library (or PCL) is a large scale, open project for point cloud processing. The PCL framework contains numerous state-of-the art algorithms including filtering, feature estimation, surface reconstruction, registration, model fitting and segmentation.
Population, imaging library in C++ for processing, analysing, modelling and visualising
(C/C++ code, CeCill lic) Population is an open-source imaging library in C++ for processing, analysing, modelling and visualising including more than 200 algorithms designed by V. Tariel.
qcv
(C/C++ code, LGPL 3) A computer vision framework based on Qt and OpenCV that provides an easy to use interface to display, analyze and run computer vision algorithms. The library is provided with multiple application examples including stereo, SURF, Sobel and and Hough transform.
Machine Vision Toolbox
(MATLAB/C, LGPL lic) image processing, segmentation, blob/line/point features, multiview geometry, camera models, colorimetry.
BoofCV
(Java code, Apache lic) BoofCV is an open source Java library for real-time computer vision and robotics applications. BoofCV is organized into several packages: image processing, features, geometric vision, calibration, visualize, and IO.
Simd
(C++ code, MIT lic) Simd is free open source library in C++. It includes high performance image processing algorithms. The algorithms are optimized with using of SIMD CPU extensions such as SSE2, SSSE3, SSE4.2 and AVX2.
Free but not open source – ArrayFire (formely LibJacket) is a matrix library for CUDA
(CUDA/C++, free lic) ArrayFire offers hundreds of general matrix and image processing functions, all running on the GPU. The syntax is very Matlab-like, with the goal of offering easy porting of Matlab code to C++/ArrayFire.

### Image Acquisition, Decoding & encoding

FFMPEG
(C/C++ code, LGPL or GPL lic) Record, convert and stream audio and video (lot of codec)
OpenCV
(C/C++ code, BSD lic) PNG, JPEG,… images, avi video files, USB webcam,…
Torch3Vision
(C/C++ code, BSD lic) Video file decoding/encoding (ffmpeg integration), image capture from a frame grabber or from USB, Sony pan/tilt/zoom camera control using VISCA interface
lib VLC
(C/C++ code, GPL lic) Used by VLC player: record, convert and stream audio and video
Live555
(C/C++ code, LGPL lic) RTSP streams
ImageMagick
(C/C++ code, GPL lic) Loading & saving DPX, EXR, GIF, JPEG, JPEG-2000, PDF, PhotoCD, PNG, Postscript, SVG, TIFF, and more
DevIL
FreeImage
VideoMan
(C/C++ code, LGPL lic) VideoMan is trying to make the image capturing process from cameras, video files or image sequences easier.

### Segmentation

OpenCV
(C/C++ code, BSD lic) Pyramid image segmentation
Branch-and-Mincut
(C/C++ code, Microsoft Research Lic) Branch-and-Mincut Algorithm for Image Segmentation
(C/C++ code) Segmentation, object category labelling, stereo

### Machine Learning

Torch
(C/C++ code, BSD lic) Gradient machines ( multi-layered perceptrons, radial basis functions, mixtures of experts, convolutional networks and even time-delay neural networks), Support vector machines, Ensemble models (bagging, adaboost), Non-parametric models (K-nearest-neighbors, Parzen regression and Parzen density estimator), distributions (Kmeans, Gaussian mixture models, hidden Markov models, input-output hidden Markov models, and Bayes classifier), speech recognition tools

### Object Detection

OpenCV
(C/C++ code, BSD lic) Viola-jones face detection (Haar features)
Torch3Vision
(C/C++ code, BSD lic) MLP & cascade of Haar-like classifiers face detection
Hough Forests
(C/C++ code, Microsoft Research Lic) Class-Specific Hough Forests for Object Detection
Efficient Subwindow Object Detection
(C/C++ code, Apache Lic) Christoph Lampert “Efficient Subwindow” algorithms for Object Detection
INRIA Object Detection and Localization Toolkit
(C/C++ code, Custom Lic) Histograms of Oriented Gradients library for Object Detection

### Object Category Labelling

(C/C++ code) Segmentation, object category labelling, stereo
Multi-label optimization
(C/C++/MATLAB code) The gco-v3.0 library is for optimizing multi-label energies. It supports energies with any combination of unary, pairwise, and label cost terms.

### Optical flow

OpenCV
(C/C++ code, BSD lic) Horn & Schunck algorithm, Lucas & Kanade algorithm, Lucas-Kanade optical flow in pyramids, block matching.
GPU-KLT+FLOW
(C/C++/OpenGL/Cg code, LGPL) Gain-Adaptive KLT Tracking and TV-L1 optical flow on the GPU.
RLOF
(C/C++/Matlab code, Custom Lic.) The RLOF library provides GPU / CPU implementation of Optical Flow and Feature Tracking method.

### Features Extraction & Matching

SIFT by R. Hess
(C/C++ code, GPL lic) SIFT feature extraction & RANSAC matching
OpenSURF
(C/C++ code) SURF feature extraction algorihtm (kind of fast SIFT)
ASIFT (from IPOL)
(C/C++ code, Ecole Polytechnique and ENS Cachan for commercial Lic) Affine SIFT (ASIFT)
VLFeat (formely Sift++)
(C/C++ code) SIFT, MSER, k-means, hierarchical k-means, agglomerative information bottleneck, and quick shift
SiftGPU
A GPU Implementation of Scale Invariant Feature Transform (SIFT)
Groupsac
(C/C++ code, GPL lic) An enhance version of RANSAC that considers the correlation between data points

### Nearest Neighbors matching

FLANN
(C/C++ code, BSD lic) Approximate Nearest Neighbors (Fast Approximate Nearest Neighbors with Automatic Algorithm Configuration)
ANN
(C/C++ code, LGPL lic) Approximate Nearest Neighbor Searching

### Tracking

OpenCV
(C/C++ code, BSD lic) Kalman, Condensation, CAMSHIFT, Mean shift, Snakes
KLT: An Implementation of the Kanade-Lucas-Tomasi Feature Tracker
(C/C++ code, public domain) Kanade-Lucas-Tomasi Feature Tracker
GPU_KLT
(C/C++/OpenGL/Cg code, ) A GPU-based Implementation of the Kanade-Lucas-Tomasi Feature Tracker
GPU-KLT+FLOW
(C/C++/OpenGL/Cg code, LGPL) Gain-Adaptive KLT Tracking and TV-L1 optical flow on the GPU
On-line boosting trackers
(C/C++, LGPL) On-line boosting tracker, semi-supervised tracker, beyond semi-supervised tracker
Single Camera background subtraction tracking
(C/C++, LGPL) Background subtraction based tracking algorithm using OpenCV.
Multi-camera tracking
(C/C++, LGPL) Multi-camera particle filter tracking algorithm using OpenCv and intel IPP.

### Simultaneous localization and mapping

Real-Time SLAM – SceneLib
(C/C++ code, LGPL lic) Real-time vision-based SLAM with a single camera
PTAM
(C/C++ code, Isis Innovation Limited lic) Parallel Tracking and Mapping for Small AR Workspaces
GTSAM
(C/C++ code, BSD lic) GTSAM is a library of C++ classes that implement smoothing and mapping (SAM) in robotics and vision, using factor graphs and Bayes networks as the underlying computing paradigm rather than sparse matrices

### Camera Calibration & constraint

OpenCV
(C/C++ code, BSD lic) Chessboard calibration, calibration with rig or pattern
Geometric camera constraint – Minimal Problems in Computer Vision
Minimal problems in computer vision arise when computing geometrical models from image data. They often lead to solving systems of algebraic equations.
Camera Calibration Toolbox for Matlab
(Matlab toolbox) Camera Calibration Toolbox for Matlab by Jean-Yves Bouguet (C implementation in OpenCV)

### Multi-View Reconstruction

(C/C++ code, GPL lic) A Generic Sparse Bundle Adjustment Package Based on the Levenberg-Marquardt Algorithm
(C/C++ code, LGPL lic) Simple Sparse Bundle Adjustment (SSBA)

### Stereo

(C/C++ code) Segmentation, object category labelling, stereo
LIBELAS: Library for Efficient LArge-scale Stereo Matching
(C/C++ code) Disparity maps, stereo

### Structure from motion

Bundler
(C/C++ code, GPL lic) A structure-from-motion system for unordered image collections
Patch-based Multi-view Stereo Software (Windows version)
(C/C++ code, GPL lic) A multi-view stereo software that takes a set of images and camera parameters, then reconstructs 3D structure of an object or a scene visible in the images
libmv – work in progress
(C/C++ code, MIT lic) A structure from motion library
(C/C++/GPU code, GPL3 lic) Design and implementation of new inexact Newton type Bundle Adjustment algorithms that exploit hardware parallelism for efficiently solving large scale 3D scene reconstruction problems.
openMVG
(C/C++/GPU code, MPL2 lic) OpenMVG (Multiple View Geometry) “open Multiple View Geometry” is a library for computer-vision scientists and especially targeted to the Multiple View Geometry community. It is designed to provide an easy access to the classical problem solvers in Multiple View Geometry and solve them accurately..

### Visual odometry

LIBVISO2: Library for VISual Odometry 2
(C/C++ code, Matlab, GPL lic) Libviso 2 is a very fast cross-platfrom (Linux, Windows) C++ library with MATLAB wrappers for computing the 6 DOF motion of a moving mono/stereo camera.

Extracts from a Personal Diary

dedicated to the life of a silent girl who eventually learnt to open up

Num3ri v 2.0

I miei numeri - seconda versione

ThuyDX

Just another WordPress.com site

Abraham Zamudio [Matematico]

Matematica Aplicada, Linux ,Programacion Cientifica , HIgh Performance COmputing, APrendizaje Automatico

josephdung

thoughts...

Tech_Raj

A great WordPress.com site

Travel tips

Travel tips

Experience the real life.....!!!

Shurwaat achi honi chahiye ...

Ronzii's Blog

Karan Jitendra Thakkar

Everything I think. Everything I do. Right here.

Chetan Solanki

Helpful to u, if u need it.....

ScreenCrush