MeanShift Class

[SerializableAttribute]
public class MeanShift : ParallelLearningBase, IUnsupervisedLearning<MeanShiftClusterCollection, double[], int>, 
	IClusteringAlgorithm<double[]>, IUnsupervisedLearning<IClusterCollection<double[]>, double[], int>

<SerializableAttribute>
Public Class MeanShift
	Inherits ParallelLearningBase
	Implements IUnsupervisedLearning(Of MeanShiftClusterCollection, Double(), Integer), 
	IClusteringAlgorithm(Of Double()), IUnsupervisedLearning(Of IClusterCollection(Of Double()), Double(), Integer)

// Use a fixed seed for reproducibility
Accord.Math.Random.Generator.Seed = 0;

// Declare some data to be clustered
double[][] input =
{
    new double[] { -5, -2, -4 },
    new double[] { -5, -5, -6 },
    new double[] {  2,  1,  1 },
    new double[] {  1,  1,  2 },
    new double[] {  1,  2,  2 },
    new double[] {  3,  1,  2 },
    new double[] { 11,  5,  4 },
    new double[] { 15,  5,  6 },
    new double[] { 10,  5,  6 },
};

// Create a new Mean-Shift algorithm for 3 dimensional samples
MeanShift meanShift = new MeanShift()
{
    // Use a uniform kernel density
    Kernel = new UniformKernel(),
    Bandwidth = 2.0
};

// Learn a data partitioning using the Mean Shift algorithm
MeanShiftClusterCollection clustering = meanShift.Learn(input);

// Predict group labels for each point
int[] labels = clustering.Decide(input);

// As a result, the first two observations should belong to the
//  same cluster (thus having the same label). The same should
//  happen to the next four observations and to the last three.

// Load a test image (shown in a picture box below)
var sampleImages = new TestImages(path: basePath);
Bitmap image = sampleImages.GetImage("airplane.png");

// ImageBox.Show("Original", image).Hold();

// Create converters to convert between Bitmap images and double[] arrays
var imageToArray = new ImageToArray(min: -1, max: +1);
var arrayToImage = new ArrayToImage(image.Width, image.Height, min: -1, max: +1);

// Transform the image into an array of pixel values
double[][] pixels; imageToArray.Convert(image, out pixels);

// Create a MeanShift algorithm using given bandwidth
//   and a Gaussian density kernel as kernel function.
MeanShift meanShift = new MeanShift()
{
    Kernel = new GaussianKernel(3),
    Bandwidth = 0.06,

    // We will compute the mean-shift algorithm until the means
    // change less than 0.05 between two iterations of the algorithm
    Tolerance = 0.05,
    MaxIterations = 10
};

// Learn the clusters from the data
var clusters = meanShift.Learn(pixels);

// Use clusters to decide class labels
int[] labels = clusters.Decide(pixels);

// Replace every pixel with its corresponding centroid
double[][] replaced = pixels.Apply((x, i) => clusters.Modes[labels[i]]);

// Retrieve the resulting image (shown in a picture box)
Bitmap result; arrayToImage.Convert(replaced, out result);

// ImageBox.Show("Mean-Shift clustering", result).Hold();