public float[] GradientDescriptorNxN(DoLF.DsLPoints lp, ZagImage <int> gradient, ZagImage <float> magnitude, int windowR = 4, int N = 3)
{
var descriptor = new float[N * N * numberGradientLevels];
int cubeNumber = 0;
for (int y = (int)lp.Y - N * windowR / 2, Y = 0; y < (lp.Y + N * windowR / 2); y += windowR, Y++)
{
for (int x = (int)lp.X - N * windowR / 2, X = 0; x < (lp.X + N * windowR / 2); x += windowR, X++)
{
for (int yy = 0; yy < windowR; yy++)
{
for (int xx = 0; xx < windowR; xx++)
{
if (y + yy < 0 || x + xx < 0 || yy + y >= gradient.Height || xx + x >= gradient.Width)
{
continue;
}
int cAngle = getAngle(gradient.Data[(y + yy) * gradient.Stride + (x + xx)]);
//angles[Y * windowR + yy, X * windowR + xx] = cAngle;
descriptor[cubeNumber * numberGradientLevels + cAngle] += magnitude.Data[(y + yy) * gradient.Stride + (x + xx)];
}
}
cubeNumber++;
}
}
return(descriptor);
}
public void CalcDoLFs(ZagImage <byte> Img)
{
if (Img.Width > 5 && Img.Height > 5)
{
ZagImage <byte> origImg = GetGrayscaleRMY(Img);
ZagImage <byte> mySmoothMedianImg = SmoothMedian(origImg);
mySmoothMedianImg = SmoothGaussian(mySmoothMedianImg);
Tuple <ZagImage <int>, ZagImage <float> > results = firstGrandient(mySmoothMedianImg);
ZagImage <int> orientationMatrix = results.Item1;
ZagImage <float> magnitudeMatrix = results.Item2;
// smoothing
orientationMatrix = SmoothMedian(orientationMatrix);
orientationMatrix = SmoothAdaptive(orientationMatrix);
ZagImage <int> quantMatrix = QuantizeFromTables(orientationMatrix);
ZagImage <int>[] levels = getLevels(quantMatrix, (int)this.QuantizationLevels);
ZagImage <byte>[] levelImg = levels.Select(x => getLevelImage(x)).ToArray();
var totalPoints = new List <DoLF.DsLPoints>();
for (int i = 0; i < levelImg.Length; i++)
{
List <DoLF.DsLPoints> points = getCenterofGravityPoints(levelImg[i], this.MinCCSize);
totalPoints.AddRange(points);
}
myDsLPs = totalPoints;
for (int i = 0; i < myDsLPs.Count(); i++)
{
DoLF.DsLPoints p = myDsLPs[i];
//p.Gradient = quantMatrix.Data[(int)(p.Y * quantMatrix.Stride + p.X)];
}
CalcFeatures(origImg, quantMatrix, magnitudeMatrix);
}
else
{
myDsLPs = new List <DoLF.DsLPoints>();
}
}
public int CalcWindowSizeAverage(DoLF.DsLPoints lp, ZagImage <byte> img, int WindowSize, int Range, int GradientN)
{
int WindowR = WindowSize / GradientN;
var pyramindWindowR = Enumerable.Range(WindowR - Range, 2 * Range).
Select(x => x * GradientN);
var averageGradientList = new List <Tuple <int, float> >();
var gradientList = new List <float>();
//get the window
foreach (var currentWindow in pyramindWindowR)
{
gradientList.Clear();
for (int y = (int)lp.Y - currentWindow / 2; y <= lp.Y + currentWindow / 2; y++)
{
if (y < 0 || y >= img.Height)
{
continue;
}
for (int x = (int)lp.X - currentWindow / 2; x <= lp.X + currentWindow / 2; x++)
{
if (x < 0 || x >= img.Width)
{
continue;
}
gradientList.Add(img.Data[y * img.Stride + x]);
}
}
averageGradientList.Add(new Tuple <int, float>(currentWindow, gradientList.Average()));
}
var localvalleys = LocalMaxima(averageGradientList.Select(x => x.Item2), 3);
int size = localvalleys.Count() > 0
? localvalleys.Select(x => averageGradientList[x.Item1]).Min(x => x.Item1)
: averageGradientList[0].Item1;
return(size);
}
