public static List <List <Vector2> > ClusterPoints(List <Vector2> points)//delete "outliers"
{
double[][] input = new double[points.Count][];
for (int i = 0; i < points.Count; i++)
{
input[i] = new double[] { points[i].x, points[i].y };
}
UniformKernel kernel = new UniformKernel();
MeanShift meanShift = new MeanShift(dimension: 2, kernel: kernel, bandwidth: 1e-2);
MeanShiftClusterCollection clustering = meanShift.Learn(input);
int[] labels = clustering.Decide(input);
List <List <Vector2> > classedPoints = new List <List <Vector2> >();
for (int i = 0; i <= Mathf.Max(labels); i++)
{
List <Vector2> iClass = new List <Vector2>();
foreach (var p in points)
{
iClass.Add(p);
}
classedPoints.Add(iClass);
}
return(classedPoints);
}
public void MeanShiftConstructorTest2()
{
Accord.Math.Tools.SetupGenerator(1);
// Declare some observations
double[][] observations =
{
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 },
};
double[][] orig = observations.MemberwiseClone();
// Create a uniform kernel density function
UniformKernel kernel = new UniformKernel();
// Create a new Mean-Shift algorithm for 3 dimensional samples
MeanShift meanShift = new MeanShift(dimension: 3, kernel: kernel, bandwidth: 2);
// Compute the algorithm, retrieving an integer array
// containing the labels for each of the observations
int[] labels = meanShift.Compute(observations);
// 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.
Assert.AreEqual(labels[0], labels[1]);
Assert.AreEqual(labels[2], labels[3]);
Assert.AreEqual(labels[2], labels[4]);
Assert.AreEqual(labels[2], labels[5]);
Assert.AreEqual(labels[6], labels[7]);
Assert.AreEqual(labels[6], labels[8]);
Assert.AreNotEqual(labels[0], labels[2]);
Assert.AreNotEqual(labels[2], labels[6]);
Assert.AreNotEqual(labels[0], labels[6]);
int[] labels2 = meanShift.Clusters.Decide(observations);
Assert.IsTrue(labels.IsEqual(labels2));
// the data must not have changed!
Assert.IsTrue(orig.IsEqual(observations));
Assert.AreEqual(3 / 9.0, meanShift.Clusters.Proportions[labels[6]], 1e-6);
Assert.AreEqual(2 / 9.0, meanShift.Clusters.Proportions[labels[0]], 1e-6);
Assert.AreEqual(4 / 9.0, meanShift.Clusters.Proportions[labels[2]], 1e-6);
}
public void meanshift_new_method()
{
#region doc_sample1
// 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 uniform kernel density function
UniformKernel kernel = new UniformKernel();
// Create a new Mean-Shift algorithm for 3 dimensional samples
MeanShift meanShift = new MeanShift(dimension: 3, kernel: kernel, bandwidth: 2);
// 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.
#endregion
Assert.AreEqual(labels[0], labels[1]);
Assert.AreEqual(labels[2], labels[3]);
Assert.AreEqual(labels[2], labels[4]);
Assert.AreEqual(labels[2], labels[5]);
Assert.AreEqual(labels[6], labels[7]);
Assert.AreEqual(labels[6], labels[8]);
Assert.AreNotEqual(labels[0], labels[2]);
Assert.AreNotEqual(labels[2], labels[6]);
Assert.AreNotEqual(labels[0], labels[6]);
int[] labels2 = meanShift.Clusters.Nearest(input);
Assert.IsTrue(labels.IsEqual(labels2));
Assert.AreEqual(3 / 9.0, meanShift.Clusters.Proportions[labels[6]], 1e-6);
Assert.AreEqual(2 / 9.0, meanShift.Clusters.Proportions[labels[0]], 1e-6);
Assert.AreEqual(4 / 9.0, meanShift.Clusters.Proportions[labels[2]], 1e-6);
}
public override void Resolve(double[] weightedColors, int startIndex, int colorsAmount, byte componentsAmount, double k,
double[] resultColor, int resultIndex)
{
var els = componentsAmount + 1;
var offs = startIndex * els;
var colors = weightedColors
.Skip(offs)
.Take(colorsAmount * els)
.ToArray();
var observations = new double[colorsAmount][];
for (int colorIndex = 0; colorIndex < colorsAmount; colorIndex++)
{
var weightedColor = new double[els];
observations[colorIndex] = weightedColor;
for (int i = 0; i < els; i++)
{
weightedColor[i] = weightedColors[offs + colorIndex * els + i];
}
}
// Create a uniform kernel density function
UniformKernel kernel = new UniformKernel();
//calculate sigma
double sigma = CalculateSigma(colors, (byte)(componentsAmount + 1));
//calc bandwidth
double bandwidth = k * sigma;
// Create a new Mean-Shift algorithm for 4 dimensional samples
MeanShift meanShift = new MeanShift(kernel: kernel, bandwidth: bandwidth);
// Compute the algorithm, retrieving an integer array
// containing the labels for each of the observations
int[] labels = meanShift.Compute(observations);
var mostCommonColor = labels
.GroupBy(item => item)
.OrderByDescending(gg => gg.Count())
.Select(gg => gg.Key)
.First();
var labeledWeightedColors = labels
.Where(l => l == mostCommonColor)
.SelectMany((label, index) => observations[index])
.ToArray();
_colorResolver.Resolve(labeledWeightedColors, 0, labeledWeightedColors.Length / els, componentsAmount, k, resultColor, resultIndex);
}
private object calcMeanShift(IPixelBlock3 vPb, IPixelBlock3 pb3)
{
double[][] jaArr = pixelBlockToJaggedArray(vPb);
int bands = vPb.Planes;
UniformKernel kernel = new UniformKernel();
//GaussianKernel kernel = new GaussianKernel(bands);
MeanShift ms = new MeanShift(bands, kernel, radius);
int[] vls = ms.Compute(jaArr, 0.05, 10);
NumClusters = ms.Clusters.Count;
Console.WriteLine(NumClusters);
return(splitArray(vls, pb3));
}
