public Bitmap ApplyMethod(Bitmap src)
{
Bitmap bitmapImage = Sodel.ApplySodel(Blur.ApplyMethod(src, 1.0));
var gradientXValues = Sodel.xGradients;
var gradientYValues = Sodel.yGradients;
ImageUtils image = new ImageUtils();
var buffer = image.BitmapToBytes(src);
var width = image.Width;
var height = image.Height;
var bytes = image.Bytes;
var cuttedImage = get4Byte(buffer);
_pixelMapM = new Dictionary <int, double[, ]>();
_pixelMapEigenValues = new Dictionary <int, Vector <Complex> >();
_pixelMapR = new Dictionary <int, double>();
var gradXValuesTwoDim = getTwoDim(gradientXValues, width, height);
var gradYValuesTwoDim = getTwoDim(gradientYValues, width, height);
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; ++j)
{
var xGrad = 0.0;
var yGrad = 0.0;
xGrad += gradXValuesTwoDim[i, j];
yGrad += gradYValuesTwoDim[i, j];
var M = new double[, ]
{
{ xGrad *xGrad,
xGrad *yGrad },
{ xGrad *yGrad,
yGrad *yGrad }
};
_pixelMapM[i * width + j] = M;
}
}
for (int i = 0; i < cuttedImage.Length; ++i)
{
var M_i = _pixelMapM[i];
Matrix <double> matrix = DenseMatrix.OfArray(M_i);
Evd <double> eigen = matrix.Evd();
Vector <Complex> eigenvector = eigen.EigenValues;
_pixelMapEigenValues[i] = eigenvector;
}
for (int i = 0; i < cuttedImage.Length; ++i)
{
var arrayEigen = _pixelMapEigenValues[i];
var det = arrayEigen[0].Real * arrayEigen[1].Real;
var k = 0.05;
var traceM = arrayEigen[0].Real + arrayEigen[1].Real;
var b = (det - k * (traceM * traceM));
_pixelMapR[i] = (_flag == 0) ? (det / traceM) : b;
}
var step = 24;
for (var i = 0; i < height; i += step)
{
for (var j = 0; j < width; j += step)
{
var max = Double.MinValue;
var maxII = 0;
var maxJJ = 0;
for (var ii = 0; ii < step; ++ii)
{
for (var jj = 0; jj < step; ++jj)
{
if (i + ii < 0 || i + ii >= height || j + jj < 0 || j + jj >= width)
{
continue;
}
if (_pixelMapR[(i + ii) * width + j + jj] > max)
{
maxII = ii;
maxJJ = jj;
max = _pixelMapR[(i + ii) * width + j + jj];
}
}
}
for (var ii = 0; ii < step; ++ii)
{
for (var jj = 0; jj < step; ++jj)
{
if (i + ii < 0 || i + ii >= height || j + jj < 0 || j + jj >= width)
{
continue;
}
if (ii != maxII || jj != maxJJ)
{
_pixelMapR[(i + ii) * width + j + jj] = 0;
}
}
}
}
}
for (var i = 0; i < height; i++)
{
for (var j = 0; j < width; j++)
{
if (Condition(_pixelMapR[i * width + j]))
{
for (var ii = -1; ii < 2; ++ii)
{
for (var jj = -1; jj < 2; ++jj)
{
if (i + ii < 0 || i + ii >= height || j + jj < 0 || j + jj >= width)
{
continue;
}
buffer[4 * ((i + ii) * width + j + jj)] = 0;
buffer[4 * ((i + ii) * width + j + jj) + 1] = 255;
buffer[4 * ((i + ii) * width + j + jj) + 2] = 0;
buffer[4 * ((i + ii) * width + j + jj) + 3] = 255;
}
}
}
}
}
Bitmap resultImage = new Bitmap(src.Width, src.Height);
BitmapData resultData = resultImage.LockBits(new Rectangle(0, 0, src.Width, src.Height),
ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
Marshal.Copy(buffer, 0, resultData.Scan0, buffer.Length);
resultImage.UnlockBits(resultData);
return(resultImage);
}
public Bitmap ApplyMethod(Bitmap src)
{
var width = src.Width;
var height = src.Height;
var scales = new double[width, height];
var gaussians = new List <Bitmap>();
var laplasians = new List <Bitmap>();
var features = new List <Point>();
var descriptors = new List <Descriptor>();
var utils = new ImageUtils();
var bitmapImage = Sodel.ApplySodel(Blur.ApplyMethod(src, 1.0));
var gradientDirections = utils.GetTwoDim(Sodel.directions, width, height);
var grayScaleSrc = utils.ColorToGrayScale(src);
for (var sigma = 0.5; sigma <= 2.5; sigma += 0.5)
{
gaussians.Add(Blur.ApplyMethod(grayScaleSrc, sigma));
}
for (var i = 0; i < gaussians.Count - 1; ++i)
{
laplasians.Add(DifferenceOfGaussians(gaussians[i + 1], gaussians[i]));
}
for (var i = 0; i < height; ++i)
{
for (var j = 0; j < width; ++j)
{
var max = 0.0;
for (var k = 0; k < laplasians.Count; ++k)
{
var pixel = laplasians[k].GetPixel(j, i).R;
if (j - 1 >= 0 && i - 1 >= 0 && j + 1 < width && i + 1 < height && pixel >= 3)
{
if (pixel >= laplasians[k].GetPixel(j - 1, i).R &&
pixel >= laplasians[k].GetPixel(j, i - 1).R &&
pixel >= laplasians[k].GetPixel(j - 1, i - 1).R &&
pixel >= laplasians[k].GetPixel(j + 1, i).R &&
pixel >= laplasians[k].GetPixel(j, i + 1).R &&
pixel >= laplasians[k].GetPixel(j + 1, i + 1).R
)
{
if (k - 1 >= 0 && pixel >= laplasians[k - 1].GetPixel(j - 1, i).R &&
pixel >= laplasians[k - 1].GetPixel(j, i - 1).R &&
pixel >= laplasians[k - 1].GetPixel(j, i).R &&
pixel >= laplasians[k - 1].GetPixel(j - 1, i - 1).R &&
pixel >= laplasians[k - 1].GetPixel(j + 1, i).R &&
pixel >= laplasians[k - 1].GetPixel(j, i + 1).R &&
pixel >= laplasians[k - 1].GetPixel(j + 1, i + 1).R
)
{
if (k + 1 < laplasians.Count && pixel >= laplasians[k + 1].GetPixel(j - 1, i).R &&
pixel >= laplasians[k - 1].GetPixel(j, i).R &&
pixel >= laplasians[k + 1].GetPixel(j, i - 1).R &&
pixel >= laplasians[k + 1].GetPixel(j - 1, i - 1).R &&
pixel >= laplasians[k + 1].GetPixel(j + 1, i).R &&
pixel >= laplasians[k + 1].GetPixel(j, i + 1).R &&
pixel >= laplasians[k + 1].GetPixel(j + 1, i + 1).R
)
{
max = (k + 1) * 0.5;
}
}
}
}
}
scales[j, i] = max;
if (max != 0)
{
features.Add(new Point(j, i));
}
}
}
foreach (var point in features)
{
if (point.Y - 16 >= 0 && point.Y + 16 < height && point.X - 16 >= 0 && point.X + 16 < width)
{
for (var i = point.Y - 8; i <= point.Y + 8; i += 4)
{
for (var j = point.X - 8; j <= point.X + 8; j += 4)
{
var gradients = new double[8];
for (var sub_i = i; sub_i < i + 4; ++sub_i)
{
for (var sub_j = j; sub_j < j + 4; ++sub_j)
{
var a = gradientDirections[sub_i, sub_j] % 360;
gradients[(int)a >= 0 ? (int)a / 45
: (360 + (int)a) / 45]++;
}
}
descriptors.Add(new Descriptor(point, new Point(j / 4, i / 4), gradients));
}
}
}
}
for (var i = 0; i < height; i++)
{
for (var j = 0; j < width; j++)
{
if (scales[j, i] > 0)
{
var threashold = scales[j, i];
for (var ii = -threashold; ii < threashold + 1; ++ii)
{
for (var jj = -threashold; jj < threashold + 1; ++jj)
{
if (i + ii < 0 || i + ii >= height || j + jj < 0 || j + jj >= width)
{
continue;
}
src.SetPixel((int)(j + jj), (int)(i + ii), Color.Green);
}
}
}
}
}
return(src);
}
