public OrientationField(int[,] bytes, int blockSize, bool isPixelwise)
{
BlockSize = blockSize;
int maxX = bytes.GetUpperBound(1) + 1;
int maxY = bytes.GetUpperBound(0) + 1;
double[,] filterX = new double[, ] {
{ -1, 0, 1 }, { -2, 0, 2 }, { -1, 0, 1 }
};
double[,] filterY = new double[, ] {
{ -1, -2, -1 }, { 0, 0, 0 }, { 1, 2, 1 }
};
double[,] doubleBytes = new double[maxY, maxX];
for (int row = 0; row < maxY; row++)
{
for (int column = 0; column < maxX; column++)
{
doubleBytes[row, column] = (double)bytes[row, column];
}
}
// градиенты
double[,] Gx = ConvolutionHelper.Convolve(doubleBytes, filterX);
double[,] Gy = ConvolutionHelper.Convolve(doubleBytes, filterY);
// разделение на блоки
this._blocks = new Block[(int)Math.Floor((float)(maxY / BlockSize)), (int)Math.Floor((float)(maxX / BlockSize))];
for (int row = 0; row < _blocks.GetUpperBound(0) + 1; row++)
{
for (int column = 0; column < _blocks.GetUpperBound(1) + 1; column++)
{
_blocks[row, column] = new Block(BlockSize, Gx, Gy, row * BlockSize, column * BlockSize);
}
}
}
static void Main(string[] args)
{
string[] pathes = Directory.GetFiles("C:\\Users\\Tanya\\Documents\\tests_data\\db");
StreamWriter writer = new StreamWriter("C:\\Users\\Tanya\\Documents\\Results\\AlgorithmVSCOMEResult.txt", true);
for (int i = 0; i < 3 /*pathes.GetLength(0)*/; i++)
{
Tuple <int, int> redPoint = ImageHelper.FindColorPoint(pathes[i]);
double[,] imgBytes = ImageEnhancementHelper.EnhanceImage(ImageHelper.LoadImage(pathes[i]));
double[,] orientationField = OrientationFieldGenerator.GenerateOrientationField(imgBytes.Select2D(x => (int)x));
Complex[,] complexOrientationField = orientationField.Select2D(x => (new Complex(Math.Cos(2 * x), Math.Sin(2 * x))));
Complex[,] filter = Filter.GetFilter(orientationField);
Complex[,] complexFilteredField = ConvolutionHelper.ComplexConvolve(complexOrientationField, filter);
double[,] filteredField = complexFilteredField.Select2D(x => x.Magnitude);
VSCOME vscome = new VSCOME(orientationField, filteredField);
double[,] vscomeValue = vscome.CalculateVscomeValue();
Tuple <int, int> corePoint = KernelHelper.Max2dPosition(vscomeValue);
writer.WriteLine(GetDistance(redPoint, corePoint));
// ImageHelper.SaveArray(orientationField, "C:\\Users\\Tanya\\Documents\\Results\\orientationField.jpg");
// ImageHelper.SaveArray(filteredField, "C:\\Users\\Tanya\\Documents\\Results\\filteredField.jpg");
//ImageHelper.SaveArray(vscomeValue, "C:\\Users\\Tanya\\Documents\\Results\\vscomeValue_1.jpg");
}
writer.Close();
}
public PixelwiseOrientationField(int[,] bytes, int blockSize)
{
BlockSize = blockSize;
int maxX = bytes.GetUpperBound(1) + 1;
int maxY = bytes.GetUpperBound(0) + 1;
double[,] filterX = new double[, ] {
{ -1, 0, 1 }, { -2, 0, 2 }, { -1, 0, 1 }
};
double[,] filterY = new double[, ] {
{ -1, -2, -1 }, { 0, 0, 0 }, { 1, 2, 1 }
};
double[,] doubleBytes = new double[maxY, maxX];
for (int row = 0; row < maxY; row++)
{
for (int column = 0; column < maxX; column++)
{
doubleBytes[row, column] = (double)bytes[row, column];
}
}
// градиенты
double[,] Gx = ConvolutionHelper.Convolve(doubleBytes, filterX);
double[,] Gy = ConvolutionHelper.Convolve(doubleBytes, filterY);
// рассчет направления для каждого пикселя
_orientation = new double[maxY, maxX];
// только один блок - персональный для каждого пикселя
for (int centerRow = 0; centerRow < maxY; centerRow++)
{
for (int centerColumn = 0; centerColumn < maxX; centerColumn++)
{
_block = new Block(_orientation, BlockSize, Gx, Gy, centerRow, centerColumn);
}
}
}
public double [] FilterGaussian(double [] F)
{
double[,] F_2D = F.Make2D(height, width);
Filter f_gaus = new Filter(sizeFil, (sizeFil - 1) / 6);
F = (ConvolutionHelper.Convolve(F_2D, f_gaus.Matrix, 1)).Make1D();
return(F);
}
private static Mat GaussBlur(Mat mat, double current, double newSigma)
{
var sigma = Math.Sqrt(MathHelper.Sqr(newSigma) - MathHelper.Sqr(current));
return
(sigma < 1e-6
? mat.Clone()
: ConvolutionHelper.Convolution(mat, Gauss.GetKernel(sigma)));
}
public static Complex[,] EsimateH2(double[,] img, double Sigma1, double Sigma2)
{
var z = GetSquaredDerectionField(img, Sigma1);
var kernel2 = KernelHelper.MakeComplexKernel((x, y) => Gaussian.Gaussian2D(x, y, Sigma2) * x, (x, y) => Gaussian.Gaussian2D(x, y, Sigma2) * (-y), KernelHelper.GetKernelSizeForGaussianSigma(Sigma2));
var I20 = ConvolutionHelper.ComplexConvolve(z, kernel2);
return(I20);
}
public static double[,] Smoothing(double[,] img, double sigma)
{
var kernel = KernelHelper.MakeKernel((x, y) => Gaussian.Gaussian2D(x, y, sigma),
KernelHelper.GetKernelSizeForGaussianSigma(sigma));
double[,] data = ConvolutionHelper.Convolve(img, kernel);
return(data);
}
public static double[,] Reduce2(double[,] source, double factor)
{
var smoothed = ConvolutionHelper.Convolve(source,
KernelHelper.MakeKernel(
(x, y) => Gaussian.Gaussian2D(x, y, factor / 2d * 0.75d), KernelHelper.GetKernelSizeForGaussianSigma(factor / 2d * 0.75d)));
var result = new double[(int)(source.GetLength(0) / factor), (int)(source.GetLength(1) / factor)];
Resize(smoothed, result, factor, (x, y) => Gaussian.Gaussian2D(x, y, factor / 2d * 0.75d));
return(result);
}
public void TestConvolutionForEvenSizedFilters()
{
var img = ImageHelper.LoadImage <double>(Resources.SampleFinger);
var kernel = KernelHelper.MakeKernel((x, y) => 1, 4);
var result = ConvolutionHelper.Convolve(img, kernel);
ImageHelper.SaveArrayAndOpen(result);
}
public static Complex[,] GetSquaredDerectionField(double[,] img, double Sigma1)
{
var kernelX = KernelHelper.MakeKernel((x, y) => Gaussian.Gaussian2D(x, y, Sigma1) * x, KernelHelper.GetKernelSizeForGaussianSigma(Sigma1));
var resultX = ConvolutionHelper.Convolve(img, kernelX);
var kernelY = KernelHelper.MakeKernel((x, y) => Gaussian.Gaussian2D(x, y, Sigma1) * -y, KernelHelper.GetKernelSizeForGaussianSigma(Sigma1));
var resultY = ConvolutionHelper.Convolve(img, kernelY);
var preZ = KernelHelper.MakeComplexFromDouble(resultX, resultY);
var z = preZ.Select2D(x => x * x);
return(z);
}
public static Complex[,] EstimatePS(double[,] img, double Sigma1, double Sigma2)
{
var z = GetSquaredDerectionField(img, Sigma1);
var kernel2 =
KernelHelper.MakeComplexKernel((x, y) => Gaussian.Gaussian2D(x, y, Sigma2) * x / (x == 0 && y == 0 ? 1 : Math.Sqrt(x * x + y * y)),
(x, y) => Gaussian.Gaussian2D(x, y, Sigma2) * y / (x == 0 && y == 0 ? 1 : Math.Sqrt(x * x + y * y)),
KernelHelper.GetKernelSizeForGaussianSigma(Sigma2));
var I20 = ConvolutionHelper.ComplexConvolve(z, kernel2);
return(I20);
}
public (I3DTensor Result, IReadOnlyList <(object X, object Y)> Index) MaxPool(
int filterWidth,
int filterHeight,
int stride,
bool calculateIndex)
{
var newColumns = (ColumnCount - filterWidth) / stride + 1;
var newRows = (RowCount - filterHeight) / stride + 1;
var matrixList = new List <CpuMatrix>();
var indexList = calculateIndex ? new List <(object X, object Y)>() : null;
var posList = ConvolutionHelper.Default(ColumnCount, RowCount, filterWidth, filterHeight, stride);
for (var k = 0; k < Depth; k++)
{
var matrix = _data[k];
var xIndex = new int[newColumns * newRows];
var yIndex = new int[newColumns * newRows];
var layer = new CpuMatrix(DenseMatrix.Create(newRows, newColumns, 0f));
foreach (var item in posList)
{
var first = item.First();
var targetX = first.X / stride;
var targetY = first.Y / stride;
var maxVal = float.MinValue;
var bestX = -1;
var bestY = -1;
foreach (var pos in item)
{
var val = matrix[pos.Y, pos.X];
if (val > maxVal || bestX == -1)
{
bestX = pos.X;
bestY = pos.Y;
maxVal = val;
}
}
var index = targetX * newRows + targetY;
xIndex[index] = bestX;
yIndex[index] = bestY;
layer[targetY, targetX] = maxVal;
}
matrixList.Add(layer);
indexList?.Add((xIndex, yIndex));
}
return(new Cpu3DTensor(matrixList), indexList);
}
public static double FindAt(Mat image, int radius, int x, int y)
{
var gauss = Gauss.GetFullKernel(radius / 3.0);
double a = 0, b = 0, c = 0;
for (var u = -radius; u <= radius; u++)
{
for (var v = -radius; v <= radius; v++)
{
var ix = ConvolutionHelper.ConvolveCell(image, SobelHelper.SobelKernelX, x + u, y + v);
var iy = ConvolutionHelper.ConvolveCell(image, SobelHelper.SobelKernelY, x + u, y + v);
var gaussPoint = gauss.GetPixel(u + radius, v + radius, BorderWrapType.Copy);
a += gaussPoint * ix * ix;
b += gaussPoint * ix * iy;
c += gaussPoint * iy * iy;
}
}
return(LambdaMin(a, b, c));
}
public IMatrix Im2Col(int filterWidth, int filterHeight, int stride)
{
var rowList = new List <float[]>();
var convolutions = ConvolutionHelper.Default(ColumnCount, RowCount, filterWidth, filterHeight, stride);
foreach (var filter in convolutions)
{
var row = new float[filter.Length * Depth];
int index = 0;
for (var k = 0; k < Depth; k++)
{
foreach (var item in filter)
{
row[index++] = this[item.Y, item.X, k];
}
}
rowList.Add(row);
}
var firstRow = rowList.First();
return(new CpuMatrix(DenseMatrix.Create(rowList.Count, firstRow.Length, (i, j) => rowList[i][j])));
}
public static Complex[,] EstimateLS(double[,] l1, double Sigma1, double Sigma2)
{
var kernelX = KernelHelper.MakeKernel((x, y) => Gaussian.Gaussian2D(x, y, Sigma1) * x, KernelHelper.GetKernelSizeForGaussianSigma(Sigma1));
var resultX = ConvolutionHelper.Convolve(l1, kernelX);
var kernelY = KernelHelper.MakeKernel((x, y) => Gaussian.Gaussian2D(x, y, Sigma1) * -y, KernelHelper.GetKernelSizeForGaussianSigma(Sigma1));
var resultY = ConvolutionHelper.Convolve(l1, kernelY);
var preZ = KernelHelper.MakeComplexFromDouble(resultX, resultY);
var z = preZ.Select2D(x => x * x);
var kernel2 = KernelHelper.MakeComplexKernel((x, y) => Gaussian.Gaussian2D(x, y, Sigma2), (x, y) => 0,
KernelHelper.GetKernelSizeForGaussianSigma(Sigma2));
var I20 = ConvolutionHelper.ComplexConvolve(z, kernel2);
var I11 = ConvolutionHelper.Convolve(z.Select2D(x => x.Magnitude), kernel2.Select2D(x => x.Real));
Complex[,] LS = KernelHelper.Zip2D(I20, I11, (x, y) => x / y);
return(LS);
}
public static double[,] GenerateOrientationField(double[,] bytes)
{
double size = 1;
double avSigma = 5;
var kernelAv = KernelHelper.MakeKernel((x, y) => Gaussian.Gaussian2D(x, y, avSigma),
KernelHelper.GetKernelSizeForGaussianSigma(avSigma));
var kernelX = KernelHelper.MakeKernel((x, y) => Gaussian.Gaussian2D(x, y, size) * x,
KernelHelper.GetKernelSizeForGaussianSigma(size));
var dx = ConvolutionHelper.Convolve(bytes, kernelX);
var kernelY = KernelHelper.MakeKernel((x, y) => Gaussian.Gaussian2D(x, y, size) * -y,
KernelHelper.GetKernelSizeForGaussianSigma(size));
var dy = ConvolutionHelper.Convolve(bytes, kernelY);
var Gxx = dx.Select2D(x => x * x);
var Gxy = dx.Select2D((x, row, column) => x * dy[row, column]);
var Gyy = dy.Select2D(x => x * x);
Gxx = ConvolutionHelper.Convolve(Gxx, kernelAv);
Gxy = ConvolutionHelper.Convolve(Gxy, kernelAv);
Gyy = ConvolutionHelper.Convolve(Gyy, kernelAv);
var angles = Gxx.Select2D((gxx, row, column) => 0.5 * Math.Atan2(2.0 * Gxy[row, column], gxx - Gyy[row, column]));
angles = angles.Select2D(angle => angle <= 0 ? angle + Math.PI / 2 : angle - Math.PI / 2);
//ImageHelper.SaveFieldAbove(bytes, angles, "C:\\temp\\orField.png");
//ImageHelper.SaveArray(angles, "C:\\temp\\angles.png");
return(angles);
}
public double[,] GaussFilter()
{
double[,] filterX = new double[, ] {
{ -3, 0, 3 }, { -10, 0, 10 }, { -3, 0, 3 }
};
double[,] filterY = new double[, ] {
{ 3, 10, 3 }, { 0, 0, 0 }, { -3, -10, -3 }
};
double[,] Gx = ConvolutionHelper.Convolve(pic, filterX);
double[,] Gy = ConvolutionHelper.Convolve(pic, filterY);
double[,] X2 = new double[height, width];
double[,] Y2 = new double[height, width];
double[,] XY = new double[height, width];
for (int i = 0; i < height; ++i)
{
for (int j = 0; j < width; ++j)
{
X2[i, j] = Gx[i, j] * Gx[i, j];
Y2[i, j] = Gy[i, j] * Gy[i, j];
XY[i, j] = Gx[i, j] * Gy[i, j];
}
}
double sigma = 0.5;
int size = KernelHelper.GetKernelSizeForGaussianSigma(sigma);
double[,] w = KernelHelper.MakeKernel((x, y) => Gaussian.Gaussian2D(x, y, sigma), size); //Gaussian filter
double[,] A = ConvolutionHelper.Convolve(X2, w);
double[,] B = ConvolutionHelper.Convolve(Y2, w);
double[,] C = ConvolutionHelper.Convolve(XY, w);
double[,] R = new double[height, width];
for (int i = 0; i < height; ++i)
{
for (int j = 0; j < width; ++j)
{
double[,] M = new double[2, 2];
M[0, 0] = A[i, j];
M[0, 1] = C[i, j];
M[1, 0] = C[i, j];
M[1, 1] = B[i, j];
double Tr = M[0, 0] + M[1, 1];
double Det = M[0, 0] * M[1, 1] - M[1, 0] * M[0, 1];
R[i, j] = Det / Tr;
}
}
double[,] matrix = new double[width, height];
for (int i = 0; i < width; ++i)
{
for (int j = 0; j < height; ++j)
{
matrix[i, j] = R[height - 1 - j, i];
}
}
return(matrix);
}
