private List <MinutiaPair> GetGlobalMatchingMtiae(IList <MinutiaPair> localMatchingPairs, MinutiaPair refMtiaPair)
{
var globalMatchingMtiae = new List <MinutiaPair>(localMatchingPairs.Count);
var qMatches = new Dictionary <Minutia, Minutia>(localMatchingPairs.Count);
var tMatches = new Dictionary <Minutia, Minutia>(localMatchingPairs.Count);
qMatches.Add(refMtiaPair.QueryMtia, refMtiaPair.TemplateMtia);
tMatches.Add(refMtiaPair.TemplateMtia, refMtiaPair.QueryMtia);
MtiaMapper mm = new MtiaMapper(refMtiaPair.QueryMtia, refMtiaPair.TemplateMtia);
Minutia refQuery = mm.Map(refMtiaPair.QueryMtia);
Minutia refTemplate = refMtiaPair.TemplateMtia;
for (int i = 1; i < localMatchingPairs.Count; i++)
{
MinutiaPair mtiaPair = localMatchingPairs[i];
if (!qMatches.ContainsKey(mtiaPair.QueryMtia) && !tMatches.ContainsKey(mtiaPair.TemplateMtia))
{
Minutia query = mm.Map(mtiaPair.QueryMtia);
Minutia template = mtiaPair.TemplateMtia;
if (MatchDistance(refQuery, refTemplate, query, template) && MatchDirections(query, template) && MatchPosition(refQuery, refTemplate, query, template))
{
globalMatchingMtiae.Add(mtiaPair);
qMatches.Add(mtiaPair.QueryMtia, mtiaPair.TemplateMtia);
tMatches.Add(mtiaPair.TemplateMtia, mtiaPair.QueryMtia);
}
}
}
globalMatchingMtiae.Add(refMtiaPair);
return(globalMatchingMtiae);
}
public static double Compare(Minutia m0, Minutia m1)
{
double diff0 = m0.Y - m1.Y;
double diff1 = m0.X - m1.X;
return(Math.Sqrt(diff0 * diff0 + diff1 * diff1));
}
/// <summary>
/// Extract features of type <see cref="JYFeatures"/> from the specified minutiae and skeleton image.
/// </summary>
/// <param name="minutiae">
/// The minutia list to extract the features from.
/// </param>
/// <param name="skeletonImg">
/// The skeleton image to extract the features from.
/// </param>
/// <returns>
/// Features of type <see cref="JYFeatures"/> extracted from the specified minutiae and skeleton image.
/// </returns>
public JYFeatures ExtractFeatures(List <Minutia> minutiae, SkeletonImage skeletonImg)
{
var descriptorsList = new List <JYMtiaDescriptor>();
if (minutiae.Count > 3)
{
var mtiaIdx = new Dictionary <Minutia, int>();
for (int i = 0; i < minutiae.Count; i++)
{
mtiaIdx.Add(minutiae[i], i);
}
for (Int16 idx = 0; idx < minutiae.Count; idx++)
{
Minutia query = minutiae[idx];
Int16[] nearest = GetNearest(minutiae, query);
for (int i = 0; i < nearest.Length - 1; i++)
{
for (int j = i + 1; j < nearest.Length; j++)
{
JYMtiaDescriptor newMTriplet = new JYMtiaDescriptor(skeletonImg, minutiae, idx, nearest[i],
nearest[j]);
descriptorsList.Add(newMTriplet);
}
}
}
descriptorsList.TrimExcess();
}
return(new JYFeatures(descriptorsList));
}
public MTriplet(Int16[] mIdxs, List <Minutia> minutiae)
{
this.minutiae = minutiae;
mtiaIdxs = ArrangeClockwise(mIdxs, minutiae);
Minutia[] mtiaArr = new Minutia[3];
mtiaArr[0] = minutiae[MtiaIdxs[0]];
mtiaArr[1] = minutiae[MtiaIdxs[1]];
mtiaArr[2] = minutiae[MtiaIdxs[2]];
// Computing distances and maxBeta angle
d[0] = ed.Compare(mtiaArr[0], mtiaArr[1]);
d[1] = ed.Compare(mtiaArr[1], mtiaArr[2]);
d[2] = ed.Compare(mtiaArr[0], mtiaArr[2]);
maxBeta = double.MinValue;
for (byte i = 0; i < 2; i++)
{
for (byte j = (byte)(i + 1); j < 3; j++)
{
if (d[sortedDistIdxs[i]] > d[sortedDistIdxs[j]])
{
byte temp = sortedDistIdxs[i];
sortedDistIdxs[i] = sortedDistIdxs[j];
sortedDistIdxs[j] = temp;
}
double alpha = mtiaArr[i].Angle;
double beta = mtiaArr[j].Angle;
double diff = Math.Abs(beta - alpha);
double currBeta = Math.Min(diff, 2 * Math.PI - diff);
maxBeta = Math.Max(maxBeta, Math.Max(currBeta, currBeta));
}
}
}
public object Clone()
{
SkeletonBuilder clone = new SkeletonBuilder();
Dictionary<Minutia, Minutia> minutiaClones = new Dictionary<Minutia, Minutia>();
foreach (Minutia minutia in AllMinutiae)
{
Minutia minutiaClone = new Minutia(minutia.Position);
minutiaClone.Valid = minutia.Valid;
clone.AddMinutia(minutiaClone);
minutiaClones[minutia] = minutiaClone;
}
Dictionary<Ridge, Ridge> ridgeClones = new Dictionary<Ridge, Ridge>();
foreach (Minutia minutia in AllMinutiae)
{
foreach (Ridge ridge in minutia.Ridges)
{
if (!ridgeClones.ContainsKey(ridge))
{
Ridge ridgeClone = new Ridge();
ridgeClone.Start = minutiaClones[ridge.Start];
ridgeClone.End = minutiaClones[ridge.End];
foreach (Point point in ridge.Points)
ridgeClone.Points.Add(point);
ridgeClones[ridge] = ridgeClone;
ridgeClones[ridge.Reversed] = ridgeClone.Reversed;
}
}
}
return clone;
}
internal static double TranslateAndMatch(List <Minutia> minutiae1, Minutia referenceMinutia1, List <Minutia> minutiae2, Minutia referenceMinutia2, double rotationAngle)
{
//from m1 to m2. I DEMAND IT
var m1 = minutiae1.Select(x => new Minutia()
{
Angle = x.Angle, X = x.X - referenceMinutia1.X, Y = x.Y - referenceMinutia1.Y
}).Reverse();
var m2 = minutiae2.Select(x => new Minutia()
{
Angle = x.Angle, X = x.X - referenceMinutia2.X, Y = x.Y - referenceMinutia2.Y
}).Reverse().ToList();
var cos = Math.Cos(rotationAngle);
var sin = -Math.Sin(rotationAngle);
foreach (var m in m1)
{
var xDash = cos * m.X - sin * m.Y;
var yDash = sin * m.X + cos * m.Y;
if (m2.Any(x => (xDash - x.X) * (xDash - x.X) + (yDash - x.Y) * (yDash - x.Y) < MatchingToleranceBox * MatchingToleranceBox))
{
m2.Remove(m2.OrderBy(x => (xDash - x.X) * (xDash - x.X) + (yDash - x.Y) * (yDash - x.Y)).First());
}
}
var total = (minutiae2.Count - m2.Count);
return(total);
}
private int[] GetAlphaCodes(MTriplet mtp)
{
int[] alpha = new int[3];
for (int i = 0; i < 3; i++)
{
int j;
if (i == 2)
{
j = 0;
}
else
{
j = i + 1;
}
Minutia qMtiai = mtp[i];
Minutia qMtiaj = mtp[j];
double x = qMtiai.X - qMtiaj.X;
double y = qMtiai.Y - qMtiaj.Y;
double angleij = Angle.ComputeAngle(x, y);
double qAlpha = Angle.Difference2Pi(qMtiai.Angle, angleij);
alpha[i] = DiscretizeAngle(qAlpha);
}
return(alpha);
}
private Int16[] GetNearest(List <Minutia> minutiae, Minutia query)
{
double[] distances = new double[neighborsCount];
Int16[] nearestM = new Int16[neighborsCount];
for (int i = 0; i < distances.Length; i++)
{
distances[i] = double.MaxValue;
}
MtiaEuclideanDistance dist = new MtiaEuclideanDistance();
for (Int16 i = 0; i < minutiae.Count; i++)
{
if (minutiae[i] != query)
{
double CurrentDistance = dist.Compare(query, minutiae[i]);
int MaxIdx = 0;
for (int j = 1; j < neighborsCount; j++)
{
if (distances[j] > distances[MaxIdx])
{
MaxIdx = j;
}
}
if (CurrentDistance < distances[MaxIdx])
{
distances[MaxIdx] = CurrentDistance;
nearestM[MaxIdx] = i;
}
}
}
return(nearestM);
}
private bool MatchBetaAngles(MtiaTriplet compareTo)
{
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
if (i != j)
{
Minutia qMtiai = minutiae[MtiaIdxs[i]];
Minutia qMtiaj = minutiae[MtiaIdxs[j]];
double x = qMtiai.X - qMtiaj.X;
double y = qMtiai.Y - qMtiaj.Y;
double angleij = Angle.ComputeAngle(x, y);
double qBeta = Angle.DifferencePi(qMtiai.Angle, angleij);
Minutia tMtiai = compareTo.minutiae[compareTo.MtiaIdxs[i]];
Minutia tMtiaj = compareTo.minutiae[compareTo.MtiaIdxs[j]];
x = tMtiai.X - tMtiaj.X;
y = tMtiai.Y - tMtiaj.Y;
angleij = Angle.ComputeAngle(x, y);
double tBeta = Angle.DifferencePi(tMtiai.Angle, angleij);
double diff = Angle.DifferencePi(qBeta, tBeta);
if (diff >= betaThr)
{
return(false);
}
}
}
}
return(true);
}
private double[] GetOrientations(int radio, Minutia mtia, OrientationImage dirImg)
{
double[] currOrientations = new double[radio / 3];
int n = radio / 3;
double incAng = 2 * Math.PI * 3.0 / radio;
for (int i = 0; i < n; i++)
{
double myAng = mtia.Angle + i * incAng;
if (myAng > 2 * Math.PI)
{
myAng -= (double)(2 * Math.PI);
}
Point pnt = SetPosToSPoint(myAng, radio, new Point(mtia.X, mtia.Y));
int row, col;
dirImg.GetBlockCoordFromPixel(pnt.X, pnt.Y, out row, out col);
if ((col < 0) || (row < 0) || (row >= dirImg.Height) ||
(col >= dirImg.Width) || (dirImg.IsNullBlock(row, col)))
{
currOrientations[i] = double.NaN;
}
else
{
currOrientations[i] =
Math.Min(Angle.DifferencePi(mtia.Angle, dirImg.AngleInRadians(row, col)),
Angle.DifferencePi(mtia.Angle, dirImg.AngleInRadians(row, col) + Math.PI));
}
}
return(currOrientations);
}
public static List <Minutia> GetMinutias(int[,] data, PixelwiseOrientationField oField)
{
int width = data.GetLength(1);
int height = data.GetLength(0);
List <Minutia> minutias = new List <Minutia>();
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
if (IsMinutia(data, x, y))
{
Minutia m = new Minutia();
m.X = x;
m.Y = y;
m.Angle = (float)GetCorrectAngle(
data,
oField,
x,
y
);
minutias.Add(m);
}
}
}
return(minutias);
}
private bool MatchDistance(Minutia refQuery, Minutia refTemplate, Minutia query, Minutia template)
{
double d0 = dist.Compare(refQuery, query);
double d1 = dist.Compare(refTemplate, template);
return(Math.Abs(d0 - d1) <= gDistThr);
}
private static double DetermineAngle(Minutia begin, Minutia end)
{
var dx = end.X - begin.X;
var dy = begin.Y - end.Y;
return(Math.Atan2(dy, dx));
}
private static bool MatchDistance(Minutia refQuery, Minutia refTemplate, Minutia query, Minutia template)
{
var d0 = MtiaEuclideanDistance.Compare(refQuery, query);
var d1 = MtiaEuclideanDistance.Compare(refTemplate, template);
return(Math.Abs(d0 - d1) <= GlobalDistThr);
}
private double MatchBetaAngles(MTriplet compareTo, byte[] order)
{
var idxArr = new[] { 0, 1, 2, 0 };
double maxdiff = 0;
for (int i = 0; i < 3; i++)
{
int j = idxArr[i + 1];
Minutia qMtiai = minutiae[MtiaIdxs[i]];
Minutia qMtiaj = minutiae[MtiaIdxs[j]];
double qbeta = Angle.Difference2Pi(qMtiai.Angle, qMtiaj.Angle);
Minutia tMtiai = compareTo.minutiae[compareTo.MtiaIdxs[order[i]]];
Minutia tMtiaj = compareTo.minutiae[compareTo.MtiaIdxs[order[j]]];
double tbeta = Angle.Difference2Pi(tMtiai.Angle, tMtiaj.Angle);
double diff1 = Math.Abs(tbeta - qbeta);
double diff = Math.Min(diff1, 2 * Math.PI - diff1);
if (diff >= aThr)
{
return(0);
}
if (diff > maxdiff)
{
maxdiff = diff;
}
}
return(1 - maxdiff / aThr);
}
private double ComputeAlpha(Minutia mtia0, Minutia mtia1)
{
double x = mtia0.X - mtia1.X;
double y = mtia0.Y - mtia1.Y;
return(Angle.Difference2Pi(mtia0.Angle, Angle.ComputeAngle(x, y)));
}
private List <MinutiaPair> GetLocalMatchingMtiae(MtripletsFeature query, MtripletsFeature template, IList <MtripletPair> matchingTriplets)
{
var minutiaMatches = new List <MinutiaPair>();
var qMatches = new Dictionary <Minutia, Minutia>(60);
var tMatches = new Dictionary <Minutia, Minutia>(60);
foreach (MtripletPair pair in matchingTriplets)
{
Minutia qMtia0 = pair.queryMTp[0];
Minutia qMtia1 = pair.queryMTp[1];
Minutia qMtia2 = pair.queryMTp[2];
Minutia tMtia0 = pair.templateMTp[pair.templateMtiaOrder[0]];
Minutia tMtia1 = pair.templateMTp[pair.templateMtiaOrder[1]];
Minutia tMtia2 = pair.templateMTp[pair.templateMtiaOrder[2]];
if (!qMatches.ContainsKey(qMtia0) || !tMatches.ContainsKey(tMtia0))
{
if (!qMatches.ContainsKey(qMtia0))
{
qMatches.Add(qMtia0, tMtia0);
}
if (!tMatches.ContainsKey(tMtia0))
{
tMatches.Add(tMtia0, qMtia0);
}
minutiaMatches.Add(new MinutiaPair {
QueryMtia = qMtia0, TemplateMtia = tMtia0
});
}
if (!qMatches.ContainsKey(qMtia1) || !tMatches.ContainsKey(tMtia1))
{
if (!qMatches.ContainsKey(qMtia1))
{
qMatches.Add(qMtia1, tMtia1);
}
if (!tMatches.ContainsKey(tMtia1))
{
tMatches.Add(tMtia1, qMtia1);
}
minutiaMatches.Add(new MinutiaPair {
QueryMtia = qMtia1, TemplateMtia = tMtia1
});
}
if (!qMatches.ContainsKey(qMtia2) || !tMatches.ContainsKey(tMtia2))
{
if (!qMatches.ContainsKey(qMtia2))
{
qMatches.Add(qMtia2, tMtia2);
}
if (!tMatches.ContainsKey(tMtia2))
{
tMatches.Add(tMtia2, qMtia2);
}
minutiaMatches.Add(new MinutiaPair {
QueryMtia = qMtia2, TemplateMtia = tMtia2
});
}
}
return(minutiaMatches);
}
private static double[] GetOrientations(int radio, Minutia mtia, OrientationImage dirImg)
{
var currOrientations = new double[radio / 3];
var n = radio / 3;
var incAng = 2 * Math.PI * 3.0 / radio;
for (var i = 0; i < n; i++)
{
var myAng = mtia.Angle + i * incAng;
if (myAng > 2 * Math.PI)
{
myAng -= 2 * Math.PI;
}
var pnt = SetPosToSPoint(myAng, radio, new Point(mtia.X, mtia.Y));
dirImg.GetBlockCoordFromPixel(pnt.X, pnt.Y, out var row, out var col);
if (col < 0 || row < 0 || row >= dirImg.Height ||
col >= dirImg.Width || dirImg.IsNullBlock(row, col))
{
currOrientations[i] = double.NaN;
}
else
{
currOrientations[i] =
Math.Min(Angle.DifferencePi(mtia.Angle, dirImg.AngleInRadians(row, col)),
Angle.DifferencePi(mtia.Angle, dirImg.AngleInRadians(row, col) + Math.PI));
}
}
return(currOrientations);
}
public MTriplet(short[] mIdxs, List <Minutia> minutiae)
{
Minutiae = minutiae;
MtiaIdxs = ArrangeClockwise(mIdxs, minutiae);
var mtiaArr = new Minutia[3];
mtiaArr[0] = minutiae[MtiaIdxs[0]];
mtiaArr[1] = minutiae[MtiaIdxs[1]];
mtiaArr[2] = minutiae[MtiaIdxs[2]];
// Computing distances and maxBeta angle
D[0] = MtiaEuclideanDistance.Compare(mtiaArr[0], mtiaArr[1]);
D[1] = MtiaEuclideanDistance.Compare(mtiaArr[1], mtiaArr[2]);
D[2] = MtiaEuclideanDistance.Compare(mtiaArr[0], mtiaArr[2]);
MaxBeta = double.MinValue;
for (byte i = 0; i < 2; i++)
{
for (var j = (byte)(i + 1); j < 3; j++)
{
if (D[SortedDistIdxs[i]] > D[SortedDistIdxs[j]])
{
var temp = SortedDistIdxs[i];
SortedDistIdxs[i] = SortedDistIdxs[j];
SortedDistIdxs[j] = temp;
}
var alpha = mtiaArr[i].Angle;
var beta = mtiaArr[j].Angle;
var diff = Math.Abs(beta - alpha);
var currBeta = Math.Min(diff, 2 * Math.PI - diff);
MaxBeta = Math.Max(MaxBeta, Math.Max(currBeta, currBeta));
}
}
}
private static short[] GetNearest(IReadOnlyList <Minutia> minutiae, Minutia query)
{
var distances = new double[NeighborsCount];
var nearestM = new short[NeighborsCount];
for (var i = 0; i < distances.Length; i++)
{
distances[i] = Double.MaxValue;
}
for (short i = 0; i < minutiae.Count; i++)
{
if (minutiae[i] != query)
{
var currentDistance = MtiaEuclideanDistance.Compare(query, minutiae[i]);
var maxIdx = 0;
for (var j = 1; j < NeighborsCount; j++)
{
if (distances[j] > distances[maxIdx])
{
maxIdx = j;
}
}
if (currentDistance < distances[maxIdx])
{
distances[maxIdx] = currentDistance;
nearestM[maxIdx] = i;
}
}
}
return(nearestM);
}
private Cylinder[] CreateCylinders(Minutia minutia)
{
Cylinder3D value = new Cylinder3D();
Cylinder3D mask = new Cylinder3D();
for (int i = 1; i <= BaseCuboid; i++)
{
for (int j = 1; j <= BaseCuboid; j++)
{
if (IsValidPoint(GetPoint(i, j, minutia), minutia))
{
for (int k = 1; k <= HeightCuboid; k++)
{
mask.SetValue(i, j, k, 1);
value.SetValue(i, j, k, StepFunction(Sum(
GetPoint(i, j, minutia),
AngleHeight(k),
GetNeighborhood(GetPoint(i, j, minutia), minutia),
minutia
)
));
}
}
}
}
return(new[]
{
new Cylinder(value.Cylinder, minutia.Angle, Math.Sqrt(CylinderHelper.GetOneBitsCount(value.Cylinder))),
new Cylinder(mask.Cylinder, minutia.Angle, Math.Sqrt(CylinderHelper.GetOneBitsCount(mask.Cylinder)))
});
}
private void MinutiaOnClick(object sender, RoutedEventArgs e)
{
ModifiedImgSingleton.Source = Minutia.MarkMinuties((BitmapSource)ModifiedImgSingleton.Source);
ModifiedImgSingleton.Source = Minutia.DeleteRepetatiobns((BitmapSource)ModifiedImgSingleton.Source);
ModifiedImgSingleton.Source = Minutia.RemoveRedundantMinutiaes((BitmapSource)ModifiedImgSingleton.Source);
ModifiedImgSingleton.Source = Minutia.DeleteFalseMinutiaes((BitmapSource)ModifiedImgSingleton.Source, 20);
ModifiedImgSingleton.Source = Minutia.MarkEndings((BitmapSource)ModifiedImgSingleton.Source);
}
private bool MatchDirections(Minutia query, Minutia template)
{
double alpha = query.Angle;
double beta = template.Angle;
double diff = Math.Abs(beta - alpha);
return(Math.Min(diff, 2 * Math.PI - diff) <= gaThr);
}
private bool EqualsMinutae(Minutia firstMinutia, Minutia secondMinutia)
{
return(
firstMinutia.X == secondMinutia.X &&
firstMinutia.Y == secondMinutia.Y &&
Math.Abs(firstMinutia.Angle - secondMinutia.Angle) < float.Epsilon
);
}
private static bool MatchDirections(Minutia query, Minutia template)
{
var alpha = query.Angle;
var beta = template.Angle;
var diff = Math.Abs(beta - alpha);
return(Math.Min(diff, 2 * Math.PI - diff) <= GaThr);
}
private void addMinutia()
{
Minutia m = new Minutia {
};
Analyzer.FingerprintData.Minutiae.Add(m);
SelectedMinutia = m;
}
internal GOwMtia(Minutia mnt, OrientationImage dImg)
{
Minutia = mnt;
Segments = new Segment[6];
for (int i = 0; i < Segments.Length; i++)
{
Segments[i] = new Segment(i * (2 * Math.PI / 6) + mnt.Angle, mnt, dImg);
}
}
private static List <MinutiaPair> GetReferenceMtiae(ICollection <MtripletPair> matchingTriplets)
{
var pairs = new List <MinutiaPair>();
var matches = new Dictionary <MinutiaPair, byte>(60);
var qMatches = new Dictionary <MTriplet, byte>(matchingTriplets.Count);
var tMatches = new Dictionary <MTriplet, byte>(matchingTriplets.Count);
foreach (var pair in matchingTriplets)
{
if (!qMatches.ContainsKey(pair.QueryMTp) || !tMatches.ContainsKey(pair.TemplateMTp))
{
var qMtia0 = pair.QueryMTp[0];
var qMtia1 = pair.QueryMTp[1];
var qMtia2 = pair.QueryMTp[2];
var tMtia0 = pair.TemplateMTp[0];
var tMtia1 = pair.TemplateMTp[1];
var tMtia2 = pair.TemplateMTp[2];
var qRefMtia = new Minutia
{
X = Convert.ToInt16(Math.Round((qMtia0.X + qMtia1.X + qMtia2.X) / 3.0)),
Y = Convert.ToInt16(Math.Round((qMtia0.Y + qMtia1.Y + qMtia2.Y) / 3.0))
};
var diffY = (Math.Sin(qMtia0.Angle) + Math.Sin(qMtia1.Angle) + Math.Sin(qMtia2.Angle)) / 3.0;
var diffX = (Math.Cos(qMtia0.Angle) + Math.Cos(qMtia1.Angle) + Math.Cos(qMtia2.Angle)) / 3.0;
qRefMtia.Angle = Angle.ComputeAngle(diffX, diffY);
var tRefMtia = new Minutia
{
X = Convert.ToInt16(Math.Round((tMtia0.X + tMtia1.X + tMtia2.X) / 3.0)),
Y = Convert.ToInt16(Math.Round((tMtia0.Y + tMtia1.Y + tMtia2.Y) / 3.0))
};
diffY = (Math.Sin(tMtia0.Angle) + Math.Sin(tMtia1.Angle) + Math.Sin(tMtia2.Angle)) / 3.0;
diffX = (Math.Cos(tMtia0.Angle) + Math.Cos(tMtia1.Angle) + Math.Cos(tMtia2.Angle)) / 3.0;
tRefMtia.Angle = Angle.ComputeAngle(diffX, diffY);
var mPair = new MinutiaPair {
QueryMtia = qRefMtia, TemplateMtia = tRefMtia
};
if (!matches.ContainsKey(mPair))
{
matches.Add(mPair, 0);
pairs.Add(mPair);
}
if (!qMatches.ContainsKey(pair.QueryMTp))
{
qMatches.Add(pair.QueryMTp, 0);
}
if (!tMatches.ContainsKey(pair.TemplateMTp))
{
tMatches.Add(pair.TemplateMTp, 0);
}
}
}
return(pairs);
}
public Minutia Map(Minutia m)
{
return(new Minutia
{
Angle = m.Angle + dAngle,
X = Convert.ToInt16(Math.Round((m.X - query.X) * Math.Cos(dAngle) - (m.Y - query.Y) * Math.Sin(dAngle) + template.X)),
Y = Convert.ToInt16(Math.Round((m.X - query.X) * Math.Sin(dAngle) + (m.Y - query.Y) * Math.Cos(dAngle) + template.Y))
});
}
private static Tuple <int, int> GetCoordinatesInFingerprint(Minutia m, int i, int j)
{
double halfNs = (1 + Constants.Ns) / 2;
double sinTetta = Math.Sin(m.Angle);
double cosTetta = Math.Cos(m.Angle);
double iDelta = cosTetta * (i - halfNs) + sinTetta * (j - halfNs);
double jDelta = -sinTetta * (i - halfNs) + cosTetta * (j - halfNs);
return(new Tuple <int, int>((int)(m.X + deltaS * iDelta), (int)(m.Y + deltaS * jDelta)));
}
private double GaussianDirection(Minutia middleMinutia, Minutia minutia, double anglePoint)
{
double common = Math.Sqrt(2) * SigmaDirection;
double angle = CylinderHelper.GetAngleDiff(anglePoint,
CylinderHelper.GetAngleDiff(middleMinutia.Angle, minutia.Angle));
double first = Erf(((angle + HeightCell / 2)) / common);
double second = Erf(((angle - HeightCell / 2)) / common);
return((first - second) / 2);
}
public Template(TemplateBuilder builder)
{
OriginalDpi = builder.OriginalDpi;
OriginalWidth = builder.OriginalWidth;
OriginalHeight = builder.OriginalHeight;
StandardDpiWidth = builder.StandardDpiWidth;
StandardDpiHeight = builder.StandardDpiHeight;
Minutiae = new Minutia[builder.Minutiae.Count];
for (int i = 0; i < builder.Minutiae.Count; ++i)
Minutiae[i] = new Minutia(builder.Minutiae[i]);
}
private static Minutia ParseOneString(string str)
{
Minutia newMinutia = new Minutia();
int x;
int y;
double angle;
Int32.TryParse(str.Split()[0], out x);
Int32.TryParse(str.Split()[1], out y);
Double.TryParse(str.Split()[0], out angle);
newMinutia.X = x;
newMinutia.Y = y;
newMinutia.Direction = angle;
return newMinutia;
}
public void Detach()
{
Start = null;
End = null;
}
public void AddMinutia(Minutia minutia)
{
AllMinutiae.Add(minutia);
}
public void RemoveMinutia(Minutia minutia)
{
AllMinutiae.Remove(minutia);
}
