public int CalculateInArea(int x, int y, int range)
{
int[] matrix1 =
{
Layer1[x, y],
Layer2[x, y],
Layer3[x, y]
};
double range1 = matrix1.Max() - matrix1.Min();//TODO think about clever use
int[] matrix2 =
{
Layer4[x, y],
Layer5[x, y],
Layer6[x, y]
};
double range2 = matrix2.Max() - matrix2.Min();//TODO think about clever use
// if (range1 < 1) range1 = 1;
//
// if (range2 < 1) range2 = 1;
//
// Console.WriteLine("R: " + range1);
// Console.WriteLine("R2: " + range2);
//Console.WriteLine("RR: " + Layer6[x,y] * Trigon.Sin(Layer3[x,y]/1000.0d*90.0d) / range1 /range2);
return((int)(Layer6[x, y] * Trigon.Sin(Layer3[x, y] / 1000.0d * 90.0d)));
}
/*Experimental method to find approximate gradient values near specified point*/
private static void CalcGradientAtPoint(int[,] blured)
{
for (var x = 0; x < blured.GetLength(0) - 4; x += 2)
{
for (var y = 0; y < blured.GetLength(1) - 4; y += 2)
{
var a = blured[x, y] +
blured[x + 1, y] +
blured[x, y + 1] +
blured[x + 1, y + 1];
var b = blured[x + 2, y] +
blured[x + 3, y] +
blured[x + 2, y + 1] +
blured[x + 3, y + 1];
var c = blured[x, y + 2] +
blured[x + 1, y + 2] +
blured[x, y + 3] +
blured[x + 1, y + 3];
var d = blured[x + 2, y + 2] +
blured[x + 3, y + 2] +
blured[x + 2, y + 3] +
blured[x + 3, y + 3];
var gx = b + d - a - c;
var gy = c + d - a - b;
_pointModule[x / 2, y / 2] = (int)Math.Sqrt(gx * gx + gy * gy);
_pointAngle[x / 2, y / 2] = (int)Trigon.AtanDouble(gy, gx);
}
}
}
private byte Average3X3(int x, int y)
{
var sumX = 0.0d;
var sumY = 0.0d;
if (IsGood(_qualityMeasure[x - 1, y - 1]))
{
sumX += SumX(_orientations[y - 1][x - 1]);
sumY += SumY(_orientations[y - 1][x - 1]);
}
if (IsGood(_qualityMeasure[x - 1, y]))
{
sumX += SumX(_orientations[y][x - 1]);
sumY += SumY(_orientations[y][x - 1]);
}
if (IsGood(_qualityMeasure[x - 1, y + 1]))
{
sumX += SumX(_orientations[y + 1][x - 1]);
sumY += SumY(_orientations[y + 1][x - 1]);
}
if (IsGood(_qualityMeasure[x, y - 1]))
{
sumX += SumX(_orientations[y - 1][x]);
sumY += SumY(_orientations[y - 1][x]);
}
if (IsGood(_qualityMeasure[x, y + 1]))
{
sumX += SumX(_orientations[y + 1][x]);
sumY += SumY(_orientations[y + 1][x]);
}
if (IsGood(_qualityMeasure[x + 1, y - 1]))
{
sumX += SumX(_orientations[y - 1][x + 1]);
sumY += SumY(_orientations[y - 1][x + 1]);
}
if (IsGood(_qualityMeasure[x + 1, y]))
{
sumX += SumX(_orientations[y][x + 1]);
sumY += SumY(_orientations[y][x + 1]);
}
if (IsGood(_qualityMeasure[x + 1, y + 1]))
{
sumX += SumX(_orientations[y + 1][x + 1]);
sumY += SumY(_orientations[y + 1][x + 1]);
}
var res = (int)(Trigon.AtanDouble(sumY, sumX) / 2.0d);
return(ToStored(res));
}
private static byte AverageDirectionInArea(int area, int x, int y)
{
var sumX = 0.0d;
var sumY = 0.0d;
for (var w = x - area; w <= x + area; w++)
{
for (var z = y - area; z <= y + area; z++)
{
sumX += _areaModule[w, z] * FastTrigon.FastCos[2 * _areaAngle[w, z]];
sumY += _areaModule[w, z] * FastTrigon.FastSin[2 * _areaAngle[w, z]];
}
}
return(ToStoredAngle(Trigon.AtanDouble(sumY, sumX)));
}
private static void CalcDirectionAtArea(int area)
{
Parallel.For(area, _pointModule.GetLength(0) - area, x => {
for (var y = area; y < _pointAngle.GetLength(1) - area; y++)
{
var sumX = 0.0d;
var sumY = 0.0d;
for (var w = x - area; w < x + area; w++)
{
for (var z = y - area; z < y + area; z++)
{
sumX += _pointModule[w, z] * FastTrigon.FastCos[2 * _pointAngle[w, z]];
sumY += _pointModule[w, z] * FastTrigon.FastSin[2 * _pointAngle[w, z]];
}
}
_areaModule[x, y] = (int)Math.Sqrt(sumX * sumX + sumY * sumY);
_areaAngle[x, y] = (int)(180.0d - Trigon.AtanDouble(sumY, sumX) / 2.0d);
}
});
}
