public void DoPaint(ImageMatrix m) { Console.WriteLine($"在{this.GetType().Name}显示图像"); }
private double GetMinutiaeAngle(ImageMatrix matrix, int x, int y, MinutiaType type) { double angle = 0; if (type == MinutiaType.End) { List <Point> points = new List <Point> { new Point(x, y) }; for (int i = 0; i < 10; i++) { List <Point> neighbors = GetNeighboors(matrix, points[points.Count - 1].X, points[points.Count - 1].Y); foreach (var neighbor in neighbors) { if (!points.Contains(neighbor)) { points.Add(neighbor); } } } if (points.Count < 10) { return(-1); } angle = Angle.ComputeAngle(points[points.Count - 1].X - points[0].X, points[points.Count - 1].Y - points[0].Y); } if (type == MinutiaType.Bifurcation) { List <Point> treeNeighboors = GetNeighboors(matrix, x, y); if (treeNeighboors.Count < 3) { return(double.NaN); } List <Point> n1 = new List <Point>() { new Point(x, y), treeNeighboors[0] }; List <Point> n2 = new List <Point>() { new Point(x, y), treeNeighboors[1] }; List <Point> n3 = new List <Point>() { new Point(x, y), treeNeighboors[2] }; for (int i = 0; i < 10; i++) { List <Point> neighboors1 = GetNeighboors(matrix, n1[n1.Count - 1].X, n1[n1.Count - 1].Y); foreach (var neighbor in neighboors1) { if (!n1.Contains(neighbor) && !treeNeighboors.Contains(neighbor)) { n1.Add(neighbor); } } List <Point> neighboors2 = GetNeighboors(matrix, n2[n2.Count - 1].X, n2[n2.Count - 1].Y); foreach (var neighbor in neighboors2) { if (!n2.Contains(neighbor) && !treeNeighboors.Contains(neighbor)) { n2.Add(neighbor); } } List <Point> neighboors3 = GetNeighboors(matrix, n3[n3.Count - 1].X, n3[n3.Count - 1].Y); foreach (var neighbor in neighboors3) { if (!n3.Contains(neighbor) && !treeNeighboors.Contains(neighbor)) { n3.Add(neighbor); } } } if (n1.Count < 10 || n2.Count < 10 || n3.Count < 10) { return(-1); } double angleNeighboors1 = Angle.ComputeAngle(n1[n1.Count - 1].X - n1[0].X, n1[n1.Count - 1].Y - n1[0].Y); double angleNeighboors2 = Angle.ComputeAngle(n2[n2.Count - 1].X - n2[0].X, n2[n2.Count - 1].Y - n2[0].Y); double angleNeighboors3 = Angle.ComputeAngle(n3[n3.Count - 1].X - n3[0].X, n3[n3.Count - 1].Y - n3[0].Y); double diff1 = Angle.DifferencePi(angleNeighboors1, angleNeighboors2); double diff2 = Angle.DifferencePi(angleNeighboors1, angleNeighboors3); double diff3 = Angle.DifferencePi(angleNeighboors2, angleNeighboors3); if (diff1 <= diff2 && diff1 <= diff3) { angle = angleNeighboors2 + diff1 / 2; if (angle > 2 * Math.PI) { angle -= 2 * Math.PI; } } else if (diff2 <= diff1 && diff2 <= diff3) { angle = angleNeighboors1 + diff2 / 2; if (angle > 2 * Math.PI) { angle -= 2 * Math.PI; } } else { angle = angleNeighboors3 + diff3 / 2; if (angle > 2 * Math.PI) { angle -= 2 * Math.PI; } } } return(angle); }
public static double[] CalculateEqualizedCumulativeHistogram(ImageMatrix image) { int[] histogram = CalculateHistogram(image); return(CalculateEqualizedCumulativeHistogram(histogram)); }
private void RemoveBadBlocksVariance(OrientationImage oi, ImageMatrix matrix) { int maxLength = oi.WindowSize / 2; int[,] varianceMatrix = new int[oi.Height, oi.Width]; double max = 0; double min = double.MaxValue; for (int row = 0; row < oi.Height; row++) { for (int col = 0; col < oi.Width; col++) { int x, y; oi.GetPixelCoordFromBlock(row, col, out x, out y); // Computing Average int sum = 0; int count = 0; for (int xi = x - maxLength; xi < x + maxLength; xi++) { for (int yi = y - maxLength; yi < y + maxLength; yi++) { if (xi >= 0 && xi < matrix.Width && yi >= 0 && yi < matrix.Height) { sum += matrix[yi, xi]; count++; } } } double avg = 1.0 * sum / count; // Computing Variance double sqrSum = 0; for (int xi = x - maxLength; xi < x + maxLength; xi++) { for (int yi = y - maxLength; yi < y + maxLength; yi++) { if (xi >= 0 && xi < matrix.Width && yi >= 0 && yi < matrix.Height) { double diff = matrix[yi, xi] - avg; sqrSum += diff * diff; } } } varianceMatrix[row, col] = Convert.ToInt32(Math.Round(sqrSum / (count - 1))); // Computing de max variance if (varianceMatrix[row, col] > max) { max = varianceMatrix[row, col]; } if (varianceMatrix[row, col] < min) { min = varianceMatrix[row, col]; } } } for (int row = 0; row < oi.Height; row++) { for (int col = 0; col < oi.Width; col++) { varianceMatrix[row, col] = Convert.ToInt32(Math.Round(254.0 * (varianceMatrix[row, col] - min) / (max - min))); } } const int t = 15; for (int row = 0; row < oi.Height; row++) { for (int col = 0; col < oi.Width; col++) { if (!oi.IsNullBlock(row, col) && varianceMatrix[row, col] <= t) { oi[row, col] = OrientationImage.Null; } } } }
private void AddMutliframedImageToCanvas(ImageMatrix imageMtx, ref int i, ref int j, int frames) { for (int frameIndex = 0; frameIndex < frames; frameIndex++, j++) { if (j >= Columns) { j = 0; i++; } Console.Out.WriteLine("Adding new MF image at Row: " + i + " Column: " + j); System.Windows.Controls.Image image = new System.Windows.Controls.Image(); var img = imageMtx.GetImage(frameIndex); ImageConverter imgConv = new ImageConverter(); var bytes = (byte[])imgConv.ConvertTo(img, typeof(byte[])); MemoryStream ms = new MemoryStream(bytes); BitmapImage bmpImg = new BitmapImage(); bmpImg.BeginInit(); bmpImg.StreamSource = ms; bmpImg.EndInit(); image.Source = bmpImg; image.Width = image.Width * ScaledWidth; image.Height = image.Height * ScaledHeight; Grid.SetRow(image, i); Grid.SetColumn(image, j); CanvasGrid.Children.Add(image); } }
private void bn_reset_Click(object sender, RoutedEventArgs e) { Game.Reset(); ImageMatrix.UpdateAll(); }
private void compareForthTransform(ImageMatrix M, int X, int Y) { int transitions, greater; for (int y = 1; y < Y; y++) { for (int x = 1; x < X; x++) { ImageMatrix.Pixel pixel = M[x, y]; if (pixel >= 0) { continue; } greater = 0; transitions = 0; if (pixel[Direction.TopLeft] < pixel) { greater = 1; } if (pixel[Direction.TopLeft] < 0 && pixel[Direction.Top] >= 0) { transitions++; } if (pixel[Direction.Top] < pixel) { greater = 1; } if (pixel[Direction.Top] < 0 && pixel[Direction.TopRight] >= 0) { transitions++; } if (pixel[Direction.TopRight] < pixel) { greater = 1; } if (pixel[Direction.TopRight] < 0 && pixel[Direction.Right] >= 0) { transitions++; } if (pixel[Direction.Left] < pixel) { greater = 1; } if (pixel[Direction.Right] < 0 && pixel[Direction.BottomRight] >= 0) { transitions++; } if (pixel[Direction.Right] < pixel) { greater = 1; } if (pixel[Direction.BottomRight] < 0 && pixel[Direction.Bottom] >= 0) { transitions++; } if (pixel[Direction.BottomLeft] < pixel) { greater = 1; } if (pixel[Direction.Bottom] < 0 && pixel[Direction.BottomLeft] >= 0) { transitions++; } if (pixel[Direction.Bottom] < pixel) { greater = 1; } if (pixel[Direction.BottomLeft] < 0 && pixel[Direction.Left] >= 0) { transitions++; } if (pixel[Direction.BottomRight] < pixel) { greater = 1; } if (pixel[Direction.Left] < 0 && pixel[Direction.TopLeft] >= 0) { transitions++; } if (greater == 1 && transitions < 2) { pixel.Luminance *= -1; } } } }
public void SetCanvas(List<NMImage> imageObjects) { try { ImageObjects = imageObjects; if (Sequential) { MessageBox.Show("Setting Sequential"); if(imageObjects[0].DicomObj == null) MessageBox.Show("Sequ set canvas null obj"); DcmObject = imageObjects[0].DicomObj; DcmImage = new ImageMatrix(imageObjects[0].FilePath); } else if (MultiFramed) { MessageBox.Show("Setting Multiframed"); if (imageObjects[0].DicomObj == null) MessageBox.Show("MF set canvas null objs"); DcmObjects = new List<DICOMObject>(); DcmImages = new List<ImageMatrix>(); int i = 0; foreach (NMImage image in imageObjects) { DcmObjects.Add(image.DicomObj); DcmImages.Add(new ImageMatrix(image.FilePath)); i++; } } //Calculate scale factor for cell dimensions int imageWidth = 0, imageHeight = 0; ScaleLayout(ref imageWidth, ref imageHeight); //Add columns with scaled widths for (int i = 0; i < Columns; i++) { ColumnDefinition colDef = new ColumnDefinition(); GridLength width = new GridLength(imageWidth * ScaledWidth); colDef.Width = width; CanvasGrid.ColumnDefinitions.Add(colDef); } //Add rows with scaled heights for (int i = 0; i < Rows; i++) { RowDefinition rowDef = new RowDefinition(); GridLength height = new GridLength(imageHeight * ScaledHeight); rowDef.Height = height; CanvasGrid.RowDefinitions.Add(rowDef); } Console.Out.WriteLine("File: " + ImageObjects[0].FilePath); //DcmImage = new ImageMatrix(ImageObjects[0].FilePath); //DcmImage.Properties.WindowAndLevel.Window = 0; //DcmImage.Properties.WindowAndLevel.Window = 0; } catch (Exception e) { MessageBox.Show("Error setting up multipframed canvas: " + e.ToString()); } }
private ImageMatrix GetBinaryImage(ImageMatrix matrix, OrientationImage orientationImage) { int[] filter = new int[] { 1, 2, 5, 7, 5, 2, 1 }; ImageMatrix newImg = new ImageMatrix(matrix.Width, matrix.Height); for (int i = 0; i < matrix.Width; i++) { for (int j = 0; j < matrix.Height; j++) { newImg[j, i] = 255; } } for (int row = 0; row < orientationImage.Height; row++) { for (int col = 0; col < orientationImage.Width; col++) { if (!orientationImage.IsNullBlock(row, col)) { int x, y; orientationImage.GetPixelCoordFromBlock(row, col, out x, out y); int maxLength = orientationImage.WindowSize / 2; for (int xi = x - maxLength; xi < x + maxLength; xi++) { for (int yi = y - maxLength; yi < y + maxLength; yi++) { int[] projection = GetProjection(orientationImage, row, col, xi, yi, matrix); int[] smoothed = new int[orientationImage.WindowSize + 1]; const int n = 7; for (int j = 0; j < projection.Length; j++) { int idx = 0; int sum = 0, count = 0; for (int k = j - n / 2; k <= j + n / 2; k++, idx++) { if (k >= 0 && k < projection.Length) { sum += projection[k] * filter[idx]; count++; } } smoothed[j] = sum / count; } int center = smoothed.Length / 2; int left; for (left = center - 1; smoothed[left] == smoothed[center] && left > 0; left--) { ; } int rigth; for (rigth = center + 1; smoothed[rigth] == smoothed[center] && rigth < smoothed.Length - 1; rigth++) { ; } if (xi >= 0 && xi < matrix.Width && yi >= 0 && yi < matrix.Height) { newImg[yi, xi] = 255; } if (xi > 0 && xi < matrix.Width - 1 && yi > 0 && yi < matrix.Height - 1 && !(left == 255 && rigth == smoothed.Length - 1)) { if (smoothed[center] < smoothed[left] && smoothed[center] < smoothed[rigth]) { newImg[yi, xi] = 0; } else if (rigth - left == 2 && ((smoothed[left] < smoothed[left - 1] && smoothed[left] < smoothed[center]) || (smoothed[rigth] < smoothed[rigth + 1] && smoothed[rigth] < smoothed[center]) || (smoothed[center] < smoothed[left - 1] && smoothed[center] < smoothed[rigth + 1]) || (smoothed[center] < smoothed[left - 1] && smoothed[center] < smoothed[rigth]) || (smoothed[center] < smoothed[left] && smoothed[center] < smoothed[rigth + 1]))) { newImg[yi, xi] = 0; } } } } } } } return(newImg); }
private bool IsContinous(ImageMatrix matrix, int x0, int y0, int x, int y, out int x1, out int y1) { x1 = -1; y1 = -1; bool isBlack = false; if (matrix[y0, x0] == 0) { matrix[y0, x0] = 255; isBlack = true; } int tl = (x > 0 && y > 0) ? matrix[y - 1, x - 1] : 255; int tc = (y > 0) ? matrix[y - 1, x] : 255; int tr = (x < matrix.Width - 1 && y > 0) ? matrix[y - 1, x + 1] : 255; int cl = (x > 0) ? matrix[y, x - 1] : 255; int ce = matrix[y, x]; int cr = (x < matrix.Width - 1) ? matrix[y, x + 1] : 255; int bl = (x > 0 && y < matrix.Height - 1) ? matrix[y + 1, x - 1] : 255; int bc = (y < matrix.Height - 1) ? matrix[y + 1, x] : 255; int br = (x < matrix.Width - 1 && y < matrix.Height - 1) ? matrix[y + 1, x + 1] : 255; if (tl == 0 && tc == 255 && tr == 255 && cl == 255 && ce == 0 && cr == 255 && bl == 255 && bc == 255 && br == 255 ) { x1 = x - 1; y1 = y - 1; if (isBlack) { matrix[y0, x0] = 0; } return(true); } if (tl == 255 && tc == 0 && tr == 255 && cl == 255 && ce == 0 && cr == 255 && bl == 255 && bc == 255 && br == 255 ) { x1 = x; y1 = y - 1; if (isBlack) { matrix[y0, x0] = 0; } return(true); } if (tl == 255 && tc == 255 && tr == 0 && cl == 255 && ce == 0 && cr == 255 && bl == 255 && bc == 255 && br == 255 ) { x1 = x + 1; y1 = y - 1; if (isBlack) { matrix[y0, x0] = 0; } return(true); } if (tl == 255 && tc == 255 && tr == 255 && cl == 255 && ce == 0 && cr == 0 && bl == 255 && bc == 255 && br == 255 ) { x1 = x + 1; y1 = y; if (isBlack) { matrix[y0, x0] = 0; } return(true); } if (tl == 255 && tc == 255 && tr == 255 && cl == 255 && ce == 0 && cr == 255 && bl == 255 && bc == 255 && br == 0 ) { x1 = x + 1; y1 = y + 1; if (isBlack) { matrix[y0, x0] = 0; } return(true); } if (tl == 255 && tc == 255 && tr == 255 && cl == 255 && ce == 0 && cr == 255 && bl == 255 && bc == 0 && br == 255 ) { x1 = x; y1 = y + 1; if (isBlack) { matrix[y0, x0] = 0; } return(true); } if (tl == 255 && tc == 255 && tr == 255 && cl == 255 && ce == 0 && cr == 255 && bl == 0 && bc == 255 && br == 255 ) { x1 = x - 1; y1 = y + 1; if (isBlack) { matrix[y0, x0] = 0; } return(true); } if (tl == 255 && tc == 255 && tr == 255 && cl == 0 && ce == 0 && cr == 255 && bl == 255 && bc == 255 && br == 255 ) { x1 = x - 1; y1 = y; if (isBlack) { matrix[y0, x0] = 0; } return(true); } return(false); }
private bool IsEnd(ImageMatrix matrix, int x, int y, out int x1, out int y1) { x1 = -1; y1 = -1; int tl = (x > 0 && y > 0) ? matrix[y - 1, x - 1] : 255; int tc = (y > 0) ? matrix[y - 1, x] : 255; int tr = (x < matrix.Width - 1 && y > 0) ? matrix[y - 1, x + 1] : 255; int cl = (x > 0) ? matrix[y, x - 1] : 255; int ce = matrix[y, x]; int cr = (x < matrix.Width - 1) ? matrix[y, x + 1] : 255; int bl = (x > 0 && y < matrix.Height - 1) ? matrix[y + 1, x - 1] : 255; int bc = (y < matrix.Height - 1) ? matrix[y + 1, x] : 255; int br = (x < matrix.Width - 1 && y < matrix.Height - 1) ? matrix[y + 1, x + 1] : 255; if (tl == 255 && tc == 255 && tr == 255 && cl == 255 && ce == 0 && cr == 255 && bl == 255 && bc == 255 && br == 255 ) { x1 = x; y1 = y; return(true); } if (tl == 0 && tc == 255 && tr == 255 && cl == 255 && ce == 0 && cr == 255 && bl == 255 && bc == 255 && br == 255 ) { x1 = x - 1; y1 = y - 1; return(true); } if (tl == 255 && tc == 0 && tr == 255 && cl == 255 && ce == 0 && cr == 255 && bl == 255 && bc == 255 && br == 255 ) { x1 = x; y1 = y - 1; return(true); } if (tl == 255 && tc == 255 && tr == 0 && cl == 255 && ce == 0 && cr == 255 && bl == 255 && bc == 255 && br == 255 ) { x1 = x + 1; y1 = y - 1; return(true); } if (tl == 255 && tc == 255 && tr == 255 && cl == 255 && ce == 0 && cr == 0 && bl == 255 && bc == 255 && br == 255 ) { x1 = x + 1; y1 = y; return(true); } if (tl == 255 && tc == 255 && tr == 255 && cl == 255 && ce == 0 && cr == 255 && bl == 255 && bc == 255 && br == 0 ) { x1 = x + 1; y1 = y + 1; return(true); } if (tl == 255 && tc == 255 && tr == 255 && cl == 255 && ce == 0 && cr == 255 && bl == 255 && bc == 0 && br == 255 ) { x1 = x; y1 = y + 1; return(true); } if (tl == 255 && tc == 255 && tr == 255 && cl == 255 && ce == 0 && cr == 255 && bl == 0 && bc == 255 && br == 255 ) { x1 = x - 1; y1 = y + 1; return(true); } if (tl == 255 && tc == 255 && tr == 255 && cl == 0 && ce == 0 && cr == 255 && bl == 255 && bc == 255 && br == 255 ) { x1 = x - 1; y1 = y; return(true); } return(false); }
private void RemoveSpikes(ImageMatrix matrix, OrientationImage orientationImage) { for (int row = 0; row < orientationImage.Height; row++) { for (int col = 0; col < orientationImage.Width; col++) { if (!orientationImage.IsNullBlock(row, col)) { double[] cos = new double[3]; double[] sin = new double[3]; double orthogonalAngle = orientationImage.AngleInRadians(row, col) + Math.PI / 2; cos[0] = Math.Cos(orthogonalAngle); sin[0] = Math.Sin(orthogonalAngle); double orthogonalAngle1 = orthogonalAngle + Math.PI / 12; cos[1] = Math.Cos(orthogonalAngle1); sin[1] = Math.Sin(orthogonalAngle1); double orthogonalAngle2 = orthogonalAngle - Math.PI / 12; cos[2] = Math.Cos(orthogonalAngle2); sin[2] = Math.Sin(orthogonalAngle2); int x, y; orientationImage.GetPixelCoordFromBlock(row, col, out x, out y); int maxLength = orientationImage.WindowSize / 2; for (int xi = x - maxLength; xi < x + maxLength; xi++) { for (int yi = y - maxLength; yi < y + maxLength; yi++) { int xj = xi; int yj = yi; bool spikeFound = true; while (spikeFound) { spikeFound = false; if (xj > 0 && xj < matrix.Width - 1 && yj > 0 && yj < matrix.Height - 1) { int tl = matrix[yj - 1, xj - 1]; int tc = matrix[yj - 1, xj]; int tr = matrix[yj - 1, xj + 1]; int le = matrix[yj, xj - 1]; int ce = matrix[yj, xj]; int ri = matrix[yj, xj + 1]; int bl = matrix[yj + 1, xj - 1]; int bc = matrix[yj + 1, xj]; int br = matrix[yj + 1, xj + 1]; if (CouldBeSpike(tl, tc, tr, le, ce, ri, bl, bc, br)) { for (int i = 0; i < sin.Length && !spikeFound; i++) { int xk = Convert.ToInt32(Math.Round(xj - cos[i])); int yk = Convert.ToInt32(Math.Round(yj - sin[i])); if (matrix[yk, xk] == 0) { matrix[yj, xj] = 255; xj = xk; yj = yk; spikeFound = true; } else { xk = Convert.ToInt32(Math.Round(xj + cos[i])); yk = Convert.ToInt32(Math.Round(yj + sin[i])); if (matrix[yk, xk] == 0) { matrix[yj, xj] = 255; xj = xk; yj = yk; spikeFound = true; } } } } } } } } } } } }
private int[] GetProjection(OrientationImage oi, int row, int col, int x, int y, ImageMatrix matrix) { double angle = oi.AngleInRadians(row, col); double orthogonalAngle = oi.AngleInRadians(row, col) + Math.PI / 2; int maxLength = oi.WindowSize / 2; int[] projection = new int[2 * maxLength + 1]; int[] outlayerCount = new int[2 * maxLength + 1]; bool outlayerFound = false; int totalSum = 0; int validPointsCount = 0; for (int li = -maxLength, i = 0; li <= maxLength; li++, i++) { int xi = Convert.ToInt32(x - li * Math.Cos(orthogonalAngle)); int yi = Convert.ToInt32(y - li * Math.Sin(orthogonalAngle)); int ySum = 0; for (int lj = -maxLength; lj <= maxLength; lj++) { int xj = Convert.ToInt32(xi - lj * Math.Cos(angle)); int yj = Convert.ToInt32(yi - lj * Math.Sin(angle)); if (xj >= 0 && yj >= 0 && xj < matrix.Width && yj < matrix.Height) { ySum += matrix[yj, xj]; validPointsCount++; } else { outlayerCount[i]++; outlayerFound = true; } } projection[i] = ySum; totalSum += ySum; } if (outlayerFound) { int avg = totalSum / validPointsCount; for (int i = 0; i < projection.Length; i++) { projection[i] += avg * outlayerCount[i]; } } return(projection); }
private bool RemoveSpikeOnMinutiae(ImageMatrix matrix, Minutia end, Minutia bifurcation) { if (bifurcation.MinutiaType == MinutiaType.Bifurcation) { int xBifur = bifurcation.X; int yBifur = bifurcation.Y; List <Point> treeNeighboors = GetNeighboors(matrix, xBifur, yBifur); if (treeNeighboors.Count < 3) { return(false); } List <Point> n1 = new List <Point> { new Point(xBifur, yBifur), treeNeighboors[0] }; List <Point> n2 = new List <Point> { new Point(xBifur, yBifur), treeNeighboors[1] }; List <Point> n3 = new List <Point> { new Point(xBifur, yBifur), treeNeighboors[2] }; int xEnd = end.X; int yEnd = end.Y; for (int i = 0; i < 15; i++) { List <Point> neighboors1 = GetNeighboors(matrix, n1[n1.Count - 1].X, n1[n1.Count - 1].Y); foreach (var neighbor in neighboors1) { if (!n1.Contains(neighbor) && !treeNeighboors.Contains(neighbor)) { if (neighbor.X == xEnd && neighbor.Y == yEnd) { return(true); } else { n1.Add(neighbor); } } } List <Point> neighboors2 = GetNeighboors(matrix, n2[n2.Count - 1].X, n2[n2.Count - 1].Y); foreach (var neighbor in neighboors2) { if (!n2.Contains(neighbor) && !treeNeighboors.Contains(neighbor)) { if (neighbor.X == xEnd && neighbor.Y == yEnd) { return(true); } else { n2.Add(neighbor); } } } List <Point> neighboors3 = GetNeighboors(matrix, n3[n3.Count - 1].X, n3[n3.Count - 1].Y); foreach (var neighbor in neighboors3) { if (!n3.Contains(neighbor) && !treeNeighboors.Contains(neighbor)) { if (neighbor.X == xEnd && neighbor.Y == yEnd) { return(true); } else { n3.Add(neighbor); } } } } } return(false); }
private void compareBackTransform(ImageMatrix M, int X, int Y) { int greater, transitions; for (int y = Y - 1; y > 0; y--) { for (int x = X - 1; x > 0; x--) { ImageMatrix.Pixel pixel = M[x, y]; if (pixel >= 0) { continue; } greater = 0; transitions = 0; if (pixel[Direction.TopLeft] < pixel) { greater = 1; } if (pixel[Direction.TopLeft] < 0 && pixel[Direction.Top] >= 0) { transitions++; } if (pixel[Direction.Top] < pixel) { greater = 1; } if (pixel[Direction.Top] < 0 && pixel[Direction.TopRight] >= 0) { transitions++; } if (pixel[Direction.TopRight] < pixel) { greater = 1; } if (pixel[Direction.TopRight] < 0 && pixel[Direction.Right] >= 0) { transitions++; } if (pixel[Direction.Left] < pixel) { greater = 1; } if (pixel[Direction.Right] < 0 && pixel[Direction.BottomRight] >= 0) { transitions++; } if (pixel[Direction.Right] < pixel) { greater = 1; } if (pixel[Direction.BottomRight] < 0 && pixel[Direction.Bottom] >= 0) { transitions++; } if (pixel[Direction.BottomLeft] < pixel) { greater = 1; } if (pixel[Direction.Bottom] < 0 && pixel[Direction.BottomLeft] >= 0) { transitions++; } if (pixel[Direction.Bottom] < pixel) { greater = 1; } if (pixel[Direction.BottomLeft] < 0 && pixel[Direction.Left] >= 0) { transitions++; } if (pixel[Direction.BottomRight] < pixel) { greater = 1; } if (pixel[Direction.Left] < 0 && pixel[Direction.TopLeft] >= 0) { transitions++; } if (greater == 1 && transitions < 2) { pixel.Luminance *= -1; } } } }
private List <Minutia> GetMinutiaes(ImageMatrix matrix, OrientationImage orientationImage) { List <Minutia> minutiaes = new List <Minutia>(); for (int row = 0; row < orientationImage.Height; row++) { for (int col = 0; col < orientationImage.Width; col++) { if (!orientationImage.IsNullBlock(row, col)) { int x, y; orientationImage.GetPixelCoordFromBlock(row, col, out x, out y); int maxLength = orientationImage.WindowSize / 2; for (int xi = x - maxLength; xi < x + maxLength; xi++) { for (int yi = y - maxLength; yi < y + maxLength; yi++) { if (xi > 0 && xi < matrix.Width - 1 && yi > 0 && yi < matrix.Height - 1) { if (matrix[yi, xi] == 0) { List <int> values = new List <int> { matrix[yi, xi + 1] == 255 ? 0 : 1, matrix[yi - 1, xi + 1] == 255 ? 0 : 1, matrix[yi - 1, xi] == 255 ? 0 : 1, matrix[yi - 1, xi - 1] == 255 ? 0 : 1, matrix[yi, xi - 1] == 255 ? 0 : 1, matrix[yi + 1, xi - 1] == 255 ? 0 : 1, matrix[yi + 1, xi] == 255 ? 0 : 1, matrix[yi + 1, xi + 1] == 255 ? 0 : 1, }; int cn = 0; for (int i = 0; i < values.Count; i++) { int idx = i; if (i == 7) { idx = -1; } cn += Math.Abs(values[i] - values[idx + 1]); } cn = (int)(cn * 0.5); double angleminu; // end minutiae if (cn == 1) { angleminu = GetMinutiaeAngle(matrix, xi, yi, MinutiaType.End); if (angleminu != -1) { minutiaes.Add(new Minutia { Angle = (float)angleminu, X = (short)xi, Y = (short)yi, MinutiaType = MinutiaType.End } ); } } //bifurcation minutiae if (cn == 3) { angleminu = GetMinutiaeAngle(matrix, xi, yi, MinutiaType.Bifurcation); if (!double.IsNaN(angleminu) && angleminu != -1) { minutiaes.Add(new Minutia { Angle = (float)angleminu, X = (short)xi, Y = (short)yi, MinutiaType = MinutiaType.Bifurcation } ); } } } } } } } } } List <Minutia> noInTheBorder = new List <Minutia>(); for (int i = 0; i < minutiaes.Count; i++) { // boundary Effects (foreground areas) int row, col; orientationImage.GetBlockCoordFromPixel(minutiaes[i].X, minutiaes[i].Y, out row, out col); if (row >= 1 && col >= 1 && col < orientationImage.Width - 1 && row < orientationImage.Height - 1) { if (! (orientationImage.IsNullBlock(row - 1, col) || orientationImage.IsNullBlock(row + 1, col) || orientationImage.IsNullBlock(row, col - 1) || orientationImage.IsNullBlock(row, col + 1) //|| ) ) { noInTheBorder.Add(minutiaes[i]); } } } MtiaEuclideanDistance miEuclideanDistance = new MtiaEuclideanDistance(); bool[] toErase = new bool[noInTheBorder.Count]; for (int i = 0; i < noInTheBorder.Count; i++) { Minutia mA = noInTheBorder[i]; for (int j = 0; j < noInTheBorder.Count; j++) { if (i != j) { Minutia mB = noInTheBorder[j]; // different to orientation image int row, col; orientationImage.GetBlockCoordFromPixel(mA.X, mA.Y, out row, out col); double angleOI = orientationImage.AngleInRadians(row, col); if (mA.MinutiaType == MinutiaType.End && Math.Min(Angle.DifferencePi(mA.Angle, angleOI), Angle.DifferencePi(mA.Angle, angleOI + Math.PI)) > Math.PI / 6) { toErase[i] = true; } // near minutiaes elimination if (mA.MinutiaType == mB.MinutiaType && miEuclideanDistance.Compare(mA, mB) < 5) { toErase[i] = toErase[j] = true; } // Ridge break elimination (Ratha) if (mA.MinutiaType == MinutiaType.End && mB.MinutiaType == MinutiaType.End && mA.Angle == mB.Angle && miEuclideanDistance.Compare(mA, mB) < 10) { toErase[i] = toErase[j] = true; } // Ridge break elimination (tavo - migue) if (mA.MinutiaType == MinutiaType.End && mB.MinutiaType == MinutiaType.End && Angle.DifferencePi(mA.Angle, mB.Angle) < Math.PI / 12 && miEuclideanDistance.Compare(mA, mB) < 10) { toErase[i] = toErase[j] = true; } // spike elimination if (mA.MinutiaType == MinutiaType.End && mB.MinutiaType == MinutiaType.Bifurcation && miEuclideanDistance.Compare(mA, mB) < 15) { if (RemoveSpikeOnMinutiae(matrix, mA, mB)) { toErase[i] = true; } } } } } List <Minutia> result = new List <Minutia>(); for (int i = 0; i < noInTheBorder.Count; i++) { if (!toErase[i]) { result.Add(noInTheBorder[i]); } } return(result); }
private char CommaOrDot(ImageMatrix matrix) { return(Math.Abs(matrix.BlacksInColumn(matrix.Width / 2) - matrix.BlacksInRow(matrix.Height / 2)) < 5 ? '.' : ','); }
private void AddSingleFrameImageToCanvas(ImageMatrix imageMtx, ref int i, ref int j) { Console.Out.WriteLine("Adding new SF image at Row: " + i + " Column: " + j); System.Windows.Controls.Image image = new System.Windows.Controls.Image(); var img = imageMtx.GetImage(0); ImageConverter imgConv = new ImageConverter(); var bytes = (byte[])imgConv.ConvertTo(img, typeof(byte[])); MemoryStream ms = new MemoryStream(bytes); BitmapImage bmpImg = new BitmapImage(); bmpImg.BeginInit(); bmpImg.StreamSource = ms; bmpImg.EndInit(); image.Source = bmpImg; image.Width = image.Width * ScaledWidth; image.Height = image.Height * ScaledHeight; Grid.SetRow(image, i); Grid.SetColumn(image, j); CanvasGrid.Children.Add(image); j++; }
public static int[] CalculateCumulativeHistogram(ImageMatrix image) { int[] histogram = CalculateHistogram(image); return(CalculateCumulativeHistogram(histogram)); }
public void SetCanvas(NMImage image) { try { DcmObject = image.DicomObj; //Calculate scale factor for cell dimensions int imageWidth = 0, imageHeight = 0; ScaleLayout(ref imageWidth, ref imageHeight); //Add columns with scaled widths for (int i = 0; i < Columns; i++) { ColumnDefinition colDef = new ColumnDefinition(); GridLength width = new GridLength(imageWidth * ScaledWidth); colDef.Width = width; CanvasGrid.ColumnDefinitions.Add(colDef); } //Add rows with scaled heights for (int i = 0; i < Rows; i++) { RowDefinition rowDef = new RowDefinition(); GridLength height = new GridLength(imageHeight * ScaledHeight); rowDef.Height = height; CanvasGrid.RowDefinitions.Add(rowDef); } Console.Out.WriteLine(image.FilePath); //var owPixel = image.DicomObj.FindFirst(TagHelper.PIXEL_DATA) as OtherWordString; //byte[] img = (owPixel.Data_).ToArray(); DcmImage = new ImageMatrix(image.FilePath); Console.Out.WriteLine("LET ME GO!!"); } catch(Exception e) { MessageBox.Show("Error setting up canvas: " + e.Message + e.StackTrace); } }
public void TestTurboMatrix() { ImageMatrix matrix = new ImageMatrix(new bool[10][] { new bool[3] { false, false, false }, new bool[3] { false, false, false }, new bool[3] { true, true, true }, new bool[3] { true, true, true }, new bool[3] { false, false, false }, new bool[3] { false, false, false }, new bool[3] { false, false, false }, new bool[3] { true, true, true }, new bool[3] { true, true, true }, new bool[3] { true, true, true } }); var turbo = new TurboMatrix(matrix); foreach (var row in turbo.Matrix) { if (row[0] != 0) { Console.WriteLine("TEST_TurboMatrix: First pixel match fail"); } if (row[1] != 2) { Console.WriteLine("TEST_TurboMatrix: Wrong number of correct pixels"); } if (row[2] != 2) { Console.WriteLine("TEST_TurboMatrix: Wrong number of correct pixels"); } if (row[3] != 3) { Console.WriteLine("TEST_TurboMatrix: Wrong number of correct pixels"); } if (row[4] != 3) { Console.WriteLine("TEST_TurboMatrix: Wrong number of correct pixels"); } } var sameTurbo = new TurboMatrix(matrix); float equality = turbo.Compare(sameTurbo) * DATA.letterHeight * DATA.letterWidth / 30; if (equality < 0.95) { Console.WriteLine("TEST_TurboMatrix: Same turbo matrix comparison failed. Equality: " + equality.ToString()); } //12233 _ 041122 var otherMatrix = new ImageMatrix(new bool[10][] { new bool[3] { true, true, true }, new bool[3] { true, true, true }, new bool[3] { true, true, true }, new bool[3] { true, true, true }, new bool[3] { false, false, false }, new bool[3] { true, true, true }, new bool[3] { false, false, false }, new bool[3] { false, false, false }, new bool[3] { true, true, true }, new bool[3] { true, true, true } }); equality = turbo.Compare(new TurboMatrix(otherMatrix)); Console.WriteLine("Equality: {0}", equality.ToString()); equality /= (float)DATA.letterHeight * DATA.letterWidth / 30; if (equality > 0.6 || equality < 0.4) { //Console.WriteLine("TEST_TurboMatrix: Expected eq of different matrixes 0.5, received: {0}", equality.ToString()); } }