public static Bitmap ImportImage()
{
// Configure open file dialog box
Microsoft.Win32.OpenFileDialog pic = new Microsoft.Win32.OpenFileDialog
{
Title = "Select an image file.",
FileName = "Picture",
DefaultExt = ".png",
};
// Show open file dialog box
Nullable <bool> result = pic.ShowDialog();
// Process open file dialog box results
if (result == true)
{
// Open document
StreamReader Stream = new StreamReader(pic.FileName);
Bitmap image = (Bitmap)Bitmap.FromStream(Stream.BaseStream);
Stream.Close();
return(image);
}
else
{
string imgPath = ("D:/Dropbox/PHYS117/Logos/Apple/Low/apple2.png");
Bitmap image = TypesAndFiles.OpenImage(imgPath);
return(image);
}
}
public static List <Point> EdgeDetectList(Bitmap bmp, double[,] filterMatX, double[,] filterMatY, int edgeLimit)
{
var pixelSource = TypesAndFiles.BitmapToByteArray(bmp);
var edgePointList = new List <Point>();
// Converting to grayscale
for (var i = 0; i < pixelSource.Length; i += 4)
{
var rgb = pixelSource[i + 0] * 0.11f;
rgb += pixelSource[i + 1] * 0.59f;
rgb += pixelSource[i + 2] * 0.3f;
pixelSource[i + 0] = (byte)rgb;
pixelSource[i + 1] = (byte)rgb;
pixelSource[i + 2] = (byte)rgb;
pixelSource[i + 3] = 255;
}
var filterWidth = filterMatX.GetLength(1);
var filterOffset = (filterWidth - 1) / 2;
for (var yy = filterOffset; yy < bmp.Height - filterOffset; yy++)
{
for (var xx = filterOffset; xx < bmp.Width - filterOffset; xx++)
{
var gx = 0.0;
var gy = 0.0;
var byteOffset = (yy * bmp.Width + xx) * 4;
// Applying filters
for (var fx = -filterOffset; fx <= filterOffset; fx++)
{
for (var fy = -filterOffset; fy <= filterOffset; fy++)
{
var calcOffset = byteOffset + (fy + fx * bmp.Width) * 4;
gx += (pixelSource[calcOffset + 0]) * filterMatX[fx + filterOffset, fy + filterOffset];
gy += (pixelSource[calcOffset + 0]) * filterMatY[fx + filterOffset, fy + filterOffset];
}
}
gx = DataLimit255(Math.Sqrt(gx * gx));
gy = DataLimit255(Math.Sqrt(gy * gy));
var grad = Math.Sqrt((gx * gx) + (gy * gy));
var p = new Point(xx, yy);
if (grad >= edgeLimit)
{
edgePointList.Add(p);
}
}
}
return(edgePointList);
}
private void Button2_Click(object sender, RoutedEventArgs e)
{
var newImage = Importer.ImportImage();
var squaredImage = Shapes.SquaredImage(newImage, _edgeLimitImage, _grayScale);
Image1.Source = TypesAndFiles.BitmapToImageSource(squaredImage);
}
private void Button1_Click(object sender, RoutedEventArgs e)
{
var newImage = Importer.ImportImage();
var filtredImage = EdgeOrientation.EdgeDetectBitmap(newImage,
Filters.Sobel3x3Horizontal, Filters.Sobel3x3Vertical, _edgeLimitImage,
true);
Image1.Source = TypesAndFiles.BitmapToImageSource(filtredImage);
}
public static Bitmap EdgeDetectBitmap(Bitmap bmp, double[,] filterMatX, double[,] filterMatY, int edgelimit, bool grayscale)
{
var pixelSource = TypesAndFiles.BitmapToByteArray(bmp);
var pixelsResult = new byte[pixelSource.Length];
if (grayscale)
{
pixelSource = TypesAndFiles.GrayscaleByteArray(pixelSource);
}
var filterWidth = filterMatX.GetLength(1);
var filterOffset = (filterWidth - 1) / 2;
for (var yy = filterOffset; yy < bmp.Height - filterOffset; yy++)
{
for (var xx = filterOffset; xx < bmp.Width - filterOffset; xx++)
{
var gx = 0.0;
var gy = 0.0;
var byteOffset = (yy * bmp.Width + xx) * 4;
// Applying filters
for (var fx = -filterOffset; fx <= filterOffset; fx++)
{
for (var fy = -filterOffset; fy <= filterOffset; fy++)
{
var calcOffset = byteOffset + (fy + fx * bmp.Width) * 4;
gx += (pixelSource[calcOffset + 0]) * filterMatX[fx + filterOffset, fy + filterOffset];
gy += (pixelSource[calcOffset + 0]) * filterMatY[fx + filterOffset, fy + filterOffset];
}
}
var grad = DataLimit255(Math.Sqrt(gx * gx + gy * gy));
if (grad < edgelimit)
{
grad = 0;
}
pixelsResult[byteOffset + 0] = (byte)(grad);
pixelsResult[byteOffset + 1] = (byte)(grad);
pixelsResult[byteOffset + 2] = (byte)(grad);
pixelsResult[byteOffset + 3] = 255;
}
}
var resultBitmap = TypesAndFiles.ByteArrayToBitmap(pixelsResult, bmp.Width, bmp.Height);
return(resultBitmap);
}
public static Bitmap SquaredImage(Bitmap bmp, int edgeLimit, bool grayscale)
{
var shapes = ShapeRectList(bmp, edgeLimit);
var bmpData = TypesAndFiles.BitmapToByteArray(bmp);
if (grayscale)
{
bmpData = TypesAndFiles.GrayscaleByteArray(bmpData);
}
var bmpSquares = SquareMarker(bmpData, bmp.Width, shapes, 2);
return(TypesAndFiles.ByteArrayToBitmap(bmpSquares, bmp.Width, bmp.Height));
}
public static Bitmap TransTest(Bitmap bmp)
// Test for transformation code
{
const int scaleX = 2;
const int scaleY = 2;
var pixelData = TypesAndFiles.BitmapToByteArray(bmp);
var newPixeldata = TransScaling(pixelData, bmp.Width, bmp.Height, bmp.Width * scaleX, bmp.Height * scaleY);
var resultBitmap = TypesAndFiles.ByteArrayToBitmap(newPixeldata, bmp.Width * scaleX, bmp.Height * scaleY);
return(resultBitmap);
}
private void Button3_Click(object sender, RoutedEventArgs e)
{
var newImage = Importer.ImportImage();
var newLogo = Importer.ImportImage();
var filteredImage = Shapes.ShapeComparison(newImage, newLogo, _edgeLimitImage,
_edgeLimitLogo, _hitCap, _grayScale);
ListView.Items.Clear();
foreach (var percent in HitRatesPercent)
{
ListView.Items.Add(percent.ToString("00.00%"));
}
Image1.Source = TypesAndFiles.BitmapToImageSource(filteredImage);
}
public static Bitmap ShapeComparison(Bitmap subjectBitmap, Bitmap logoBitmap, int edgeLimitSub, int edgeLimitLogo,
double hitRate, bool grayscale)
{
var rectListSub = ShapeRectList(subjectBitmap, edgeLimitSub);
var rectListLogo = ShapeRectList(logoBitmap, edgeLimitLogo);
var pixelsSubject = TypesAndFiles.BitmapToByteArray(subjectBitmap);
var pixelsLogo = TypesAndFiles.BitmapToByteArray(logoBitmap);
var pixelResult = pixelsSubject;
if (grayscale)
{
pixelsSubject = TypesAndFiles.GrayscaleByteArray(pixelsSubject);
pixelsLogo = TypesAndFiles.GrayscaleByteArray(pixelsLogo);
}
//var compareList = new List<Point>();
var previousHits = new List <double>();
//FileReader.ExtractArray(pixelsSubject, rectListSub, subjectBitmap.Width, 0);
for (var i = 0; i < rectListSub.Count / 2; i++)
{
previousHits.Add(0.0);
}
// Comparison by subtraction
for (var j = 0; j < rectListLogo.Count; j += 2)
{
for (var i = 0; i < rectListSub.Count; i += 2)
{
var subShapeWidth = rectListSub[i + 1].X - rectListSub[i].X + 1;
var subShapeHeight = rectListSub[i + 1].Y - rectListSub[i].Y + 1;
var logoShapeWidth = rectListLogo[j + 1].X - rectListLogo[j].X + 1;
var logoShapeHeight = rectListLogo[j + 1].Y - rectListLogo[j].Y + 1;
var newArrSub = TypesAndFiles.ExtractArray(pixelsSubject, rectListSub, subjectBitmap.Width, i);
var newArrLogo = TypesAndFiles.ExtractArray(pixelsLogo, rectListLogo, logoBitmap.Width, j);
var rate = 0.0;
var b = 0;
if (logoShapeHeight == subShapeHeight && logoShapeWidth == subShapeWidth)
{
var db = 0.0;
var dg = 0.0;
var dr = 0.0;
for (var yy = 0; yy < logoShapeHeight; yy++)
{
for (var xx = 0; xx < logoShapeWidth; xx++)
{
var byteOffset = (yy * logoShapeWidth + xx) * 4;
db += Math.Abs(newArrSub[byteOffset + 0] - newArrLogo[byteOffset + 0]);
dg += Math.Abs(newArrSub[byteOffset + 1] - newArrLogo[byteOffset + 1]);
dr += Math.Abs(newArrSub[byteOffset + 2] - newArrLogo[byteOffset + 2]);
b++;
}
}
db = db / (b * 255);
dg = dg / (b * 255);
dr = dr / (b * 255);
rate = 1 - (db + dg + dr) / 3;
if (previousHits[i / 2] > rate)
{
continue;
}
previousHits[i / 2] = rate;
}
else
{
var newArrSubScaled = Transformations.TransScaling(newArrSub, subShapeHeight, subShapeWidth, logoShapeHeight, logoShapeWidth);
var db = 0.0;
var dg = 0.0;
var dr = 0.0;
for (var yy = 0; yy < logoShapeHeight; yy++)
{
for (var xx = 0; xx < logoShapeWidth; xx++)
{
var byteOffset = (yy * logoShapeWidth + xx) * 4;
db += Math.Abs(newArrSubScaled[byteOffset + 0] - newArrLogo[byteOffset + 0]);
dg += Math.Abs(newArrSubScaled[byteOffset + 1] - newArrLogo[byteOffset + 1]);
dr += Math.Abs(newArrSubScaled[byteOffset + 2] - newArrLogo[byteOffset + 2]);
b++;
}
}
db = db / (b * 255);
dg = dg / (b * 255);
dr = dr / (b * 255);
rate = 1 - (db + dg + dr) / 3;
if (previousHits[i / 2] > rate)
{
continue;
}
previousHits[i / 2] = rate;
}
}
}
// Marking every shape wwith a hitrate above hitcap
for (var j = 0; j < rectListSub.Count; j += 2)
{
if (previousHits[j / 2] < hitRate)
{
continue;
}
var shapelist = new List <Point> {
rectListSub[j], rectListSub[j + 1]
};
pixelResult = SquareMarker(pixelResult, subjectBitmap.Width, shapelist, previousHits[j / 2]);
}
// Kunne brukt pixelSubject, men god huskeregel å ikke endre data man leser av.
MainWindow.HitRatesPercent = previousHits;
var resultBitmap = TypesAndFiles.ByteArrayToBitmap(pixelResult, subjectBitmap.Width, subjectBitmap.Height);
return(resultBitmap);
}
