private void DoTestCancelMinutia()
{
using (Fake.CreateScope())
{
// PREPARE:
m_Monitor.Reset();
// Copy the minutae before the operation
IEnumerable <MinutiaRecord> minutae = m_ViewModel.Minutae.ToArray();
// Record the input minutia type before the operation
MinutiaType inputType = m_ViewModel.InputMinutiaType;
// EXECUTE:
m_IViewModel.EscapeAction();
// ASSERT:
Assert.AreEqual(CAPTURE_NO_TEMPLATE, m_ViewModel.Capture);
Assert.AreEqual(inputType, m_ViewModel.InputMinutiaType);
Assert.AreEqual(m_ViewModel.Minutae.Count() > 0, m_IViewModel.IsSaveTemplatePermitted);
// Assert that the user is prompted to add a minutia
IEnumerable <UserActionRequiredEventArgs> userActionEvents = m_Monitor.GetEventResponses <UserActionRequiredEventArgs>("UserActionRequired");
Assert.AreEqual(1, userActionEvents.Count());
Assert.AreEqual(INPUT_MINUTIA_PROMPT, userActionEvents.ElementAt(0).PromptText);
Assert.AreEqual(0, m_Monitor.GetEventResponses <PropertyChangedEventArgs>("PropertyChanged").Count());
// Assert previous minuae are unchanged (note Equals has been overriden)
Assert.AreEqual(minutae.Count() - 1, m_ViewModel.Minutae.Count());
CollectionAssert.AreEqual(
minutae.Take(minutae.Count() - 1).ToArray(),
m_ViewModel.Minutae.ToArray());
// Assert IDispatcherHelper interaction
AssertNoCallsToDispatcherHelper();
}
}
private void DoTestRemoveMinutia(int index)
{
using (Fake.CreateScope())
{
// PREPARE:
m_Monitor.Reset();
IEnumerable <MinutiaRecord> minutae = m_ViewModel.Minutae.ToArray();
// Record the input minutia type before the operation
MinutiaType inputType = m_ViewModel.InputMinutiaType;
// EXECUTE:
m_ViewModel.RemoveMinutia(index);
// ASSERT:
Assert.AreEqual(CAPTURE_NO_TEMPLATE, m_ViewModel.Capture);
Assert.AreEqual(inputType, m_ViewModel.InputMinutiaType);
Assert.AreEqual(m_ViewModel.Minutae.Count() > 0, m_IViewModel.IsSaveTemplatePermitted);
Assert.AreEqual(0, m_Monitor.GetEventResponses <UserActionRequiredEventArgs>("UserActionRequired").Count());
Assert.AreEqual(0, m_Monitor.GetEventResponses <PropertyChangedEventArgs>("PropertyChanged").Count());
// Assert previous minuae are unchanged (note Equals has been overriden)
Assert.AreEqual(minutae.Count() - 1, m_ViewModel.Minutae.Count());
CollectionAssert.AreEqual(
minutae.Where((minutia, i) => i != index).ToArray(),
m_ViewModel.Minutae.ToArray());
// Assert IDispatcherHelper interaction
AssertNoCallsToDispatcherHelper();
}
}
private void DoTestFinaliseTemplate()
{
using (Fake.CreateScope())
{
// PREPARE
m_Monitor.Reset();
IEnumerable <MinutiaRecord> minutae = m_ViewModel.Minutae.ToArray();
// Record the input minutia type before the operation
MinutiaType inputType = m_ViewModel.InputMinutiaType;
// EXECUTE:
byte[] template = m_IViewModel.FinaliseTemplate();
// ASSERT:
// First check that the template is correctly converted
CollectionAssert.AreEqual(
IsoTemplateHelper.ToIsoTemplate(minutae),
template);
// Check the workspace is cleared
Assert.AreEqual(CAPTURE_NO_TEMPLATE, m_ViewModel.Capture);
Assert.IsTrue(m_IViewModel.IsSaveTemplatePermitted);
Assert.AreEqual(minutae.Count(), m_ViewModel.Minutae.Count());
Assert.AreEqual(0, m_Monitor.GetEventResponses <UserActionRequiredEventArgs>("UserActionRequired").Count());
Assert.AreEqual(0, m_Monitor.GetEventResponses <PropertyChangedEventArgs>("PropertyChanged").Count());
Assert.AreEqual(inputType, m_ViewModel.InputMinutiaType);
}
}
public Minutia(TemplateBuilder.Minutia builderMinutia)
{
Position = new PointS(builderMinutia.Position);
Direction = builderMinutia.Direction;
switch (builderMinutia.Type)
{
case TemplateBuilder.MinutiaType.Ending: Type = MinutiaType.Ending; break;
case TemplateBuilder.MinutiaType.Bifurcation: Type = MinutiaType.Bifurcation; break;
case TemplateBuilder.MinutiaType.Other: Type = MinutiaType.Other; break;
default: throw new ApplicationException();
}
}
public Minutia(TemplateBuilder.Minutia builderMinutia)
{
Position = new PointS(builderMinutia.Position);
Direction = builderMinutia.Direction;
if (builderMinutia.Type == TemplateBuilder.MinutiaType.Extremidade)
{
Type = MinutiaType.Ending;
}
else
{
Type = MinutiaType.Bifurcation;
}
}
private void DoTestSetMinutia()
{
using (Fake.CreateScope())
{
// PREPARE:
m_Monitor.Reset();
// Create a random point to update the minutia with
Point setPosition = new Point(
m_Random.Next(MAX_IMAGE_SIZE),
m_Random.Next(MAX_IMAGE_SIZE));
// Copy the minutae before the operation
IEnumerable <MinutiaRecord> minutae = m_ViewModel.Minutae.ToArray();
// Record the input minutia type before the operation
MinutiaType inputType = m_ViewModel.InputMinutiaType;
// EXECUTE:
m_ViewModel.PositionInput(setPosition);
// ASSERT:
Assert.AreEqual(CAPTURE_NO_TEMPLATE, m_ViewModel.Capture);
Assert.AreEqual(inputType, m_ViewModel.InputMinutiaType);
Assert.AreEqual(minutae.Count(), m_ViewModel.Minutae.Count);
Assert.AreEqual((m_ViewModel.Minutae.Count() > 0), m_IViewModel.IsSaveTemplatePermitted);
// Assert that the user is prompted to add a new minutia
IEnumerable <UserActionRequiredEventArgs> userActionEvents = m_Monitor.GetEventResponses <UserActionRequiredEventArgs>("UserActionRequired");
Assert.AreEqual(1, userActionEvents.Count());
Assert.AreEqual(INPUT_MINUTIA_PROMPT, userActionEvents.ElementAt(0).PromptText);
// Assert that no bound properties were changed
Assert.AreEqual(0, m_Monitor.GetEventResponses <PropertyChangedEventArgs>("PropertyChanged").Count());
// Assert previous minuae are unchanged (note Equals has been overridden)
Assert.AreEqual(minutae.Count(), m_ViewModel.Minutae.Count());
CollectionAssert.AreEqual(
minutae.Take(minutae.Count() - 1).ToArray(),
m_ViewModel.Minutae.Take(minutae.Count() - 1).ToArray());
// Assert set minutia properties
Assert.AreEqual(minutae.Last().Position, m_ViewModel.Minutae.Last().Position);
Assert.AreEqual(minutae.Last().Type, m_ViewModel.Minutae.Last().Type);
Assert.AreEqual(inputType, m_ViewModel.Minutae.Last().Type);
Vector direction = (setPosition - minutae.Last().Position);
Assert.AreEqual(
MathsHelper.RadianToDegree(Math.Atan2(direction.Y, direction.X)),
m_ViewModel.Minutae.Last().Angle);
// Assert IDispatcherHelper interaction
AssertNoCallsToDispatcherHelper();
}
}
private static MinutiaType TypeToMinutiaType(byte typeData)
{
MinutiaType type = MinutiaType.None;
if (typeData == TERMINATION)
{
type = MinutiaType.Termination;
}
else if (typeData == BIFURICATION)
{
type = MinutiaType.Bifurication;
}
return(type);
}
public List <Minutia> detectMinituae(Image fingerprintSkeleton)
{
var types = MinutiaType.GetAllValues();
List <Minutia> minutiae = new List <Minutia>();
Random randVal = new Random(413);
for (int i = 0; i < types.Length; i++)
{
Minutia minutia = new Minutia {
Type = types[i], X = (float)randVal.NextDouble(), Y = (float)randVal.NextDouble()
};
minutiae.Add(minutia);
}
return(minutiae);
}
public Minutia(TemplateBuilder.Minutia builderMinutia)
{
Position = new PointS(builderMinutia.Position);
Direction = builderMinutia.Direction;
switch (builderMinutia.Type)
{
case TemplateBuilder.MinutiaType.Ending: Type = MinutiaType.Ending; break;
case TemplateBuilder.MinutiaType.Bifurcation: Type = MinutiaType.Bifurcation; break;
case TemplateBuilder.MinutiaType.Other: Type = MinutiaType.Other; break;
default: throw new ApplicationException();
}
}
public static IEnumerable <MinutiaRecord> ToMinutae(byte[] isoTemplate)
{
IntegrityCheck.IsNotNull(isoTemplate);
// TODO: IntegrityCheck start is HEADER_TOP
// TODO: IntegrityCheck HEADER_BOTTOM
int headerTopCount = ToByteArray(HEADER_TOP).Count(); // TODO: Make constant
int minutiaCount_1 = ToMinutiaCount(isoTemplate[headerTopCount]);
int headerBottomCount = ToByteArray(HEADER_BOTTOM).Count(); // TODO: Make constant
int minutiaCount_2 = (UInt16)isoTemplate[headerTopCount + 1 + headerBottomCount];
// TODO: IntegrityCheck minutiaCount_1 == minutiaCount_2
int minutiaCount = minutiaCount_1;
int startByte = headerTopCount + 1 + headerBottomCount + 1; // TODO: Make constant
int bytesPerMinutia = 6; // TODO: Make constant
List <MinutiaRecord> minutae = new List <MinutiaRecord>(minutiaCount);
for (int i = 0; i < minutiaCount; i++)
{
MinutiaType type = TypeToMinutiaType(isoTemplate[startByte]);
// TODO: IntegrityCheck type != None
// Get Minutia X-Position
int x = (UInt16)isoTemplate[startByte + 1];
// Get Minutia Y-Position
byte[] yData = new byte[2];
Array.Copy(isoTemplate, startByte + 2, yData, 0, 2);
int y = YToInt(yData);
// Get Minutia angle from the two angle bytes.
double angle = AngleToDouble(isoTemplate[startByte + 4]);
// TODO: IntegrityCheck quality
// Create minutia from data and add to list.
MinutiaRecord minutia = new MinutiaRecord(
new System.Windows.Point(x, y),
angle,
type);
minutae.Add(minutia);
startByte += bytesPerMinutia;
}
// TODO: More assertions
return(minutae);
}
private static byte TypeToByte(MinutiaType type)
{
byte typeData;
switch (type)
{
case MinutiaType.Termination:
typeData = TERMINATION;
break;
case MinutiaType.Bifurication:
typeData = BIFURICATION;
break;
default:
throw IntegrityCheck.FailUnexpectedDefault(type);
}
return(typeData);
}
private void DoTestAddMinutia()
{
using (Fake.CreateScope())
{
// PREPARE
m_Monitor.Reset();
// Create a random minutia position
Point newMinutiaPosition = new Point(
m_Random.Next(MAX_IMAGE_SIZE),
m_Random.Next(MAX_IMAGE_SIZE));
// Copy the minutae before the operation
IEnumerable <MinutiaRecord> minutae = m_ViewModel.Minutae.ToArray();
// Record the input minutia type before the operation
MinutiaType inputType = m_ViewModel.InputMinutiaType;
// EXECUTE
// TODO: Should there be a check on position vs. image size?
m_ViewModel.PositionInput(newMinutiaPosition);
// ASSERT
Assert.AreEqual(CAPTURE_NO_TEMPLATE, m_ViewModel.Capture);
Assert.AreEqual(inputType, m_ViewModel.InputMinutiaType);
Assert.IsFalse(m_IViewModel.IsSaveTemplatePermitted);
// UserActionRequired prompting to input angle
IEnumerable <UserActionRequiredEventArgs> userActionEvents = m_Monitor.GetEventResponses <UserActionRequiredEventArgs>("UserActionRequired");
Assert.AreEqual(1, userActionEvents.Count());
Assert.AreEqual(INPUT_ANGLE_PROMPT, userActionEvents.ElementAt(0).PromptText);
Assert.AreEqual(0, m_Monitor.GetEventResponses <PropertyChangedEventArgs>("PropertyChanged").Count());
// Assert previous minuae are unchanged (note Equals has been overriden)
CollectionAssert.AreEqual(minutae.ToArray(), m_ViewModel.Minutae.Take(minutae.Count()).ToArray());
// Assert new minutia properties
Assert.AreEqual(minutae.Count() + 1, m_ViewModel.Minutae.Count());
Assert.AreEqual(newMinutiaPosition, m_ViewModel.Minutae.Last().Position);
Assert.AreEqual(inputType, m_ViewModel.Minutae.Last().Type);
Assert.AreEqual(0, m_ViewModel.Minutae.Last().Angle);
// Assert IDispatcherHelper interaction
AssertNoCallsToDispatcherHelper();
}
}
public virtual void SetMinutiaType(MinutiaType type)
{
MethodNotImplemented();
}
public MutableMinutia(IntPoint position, double direction, MinutiaType type)
{
Position = position;
Direction = direction;
Type = type;
}
public override void SetMinutiaType(MinutiaType type)
{
// Ignore. No current record to update.
}
public ImmutableMinutia(MutableMinutia mutable)
{
Position = mutable.Position;
Direction = mutable.Direction;
Type = mutable.Type;
}
private static double GetMinutiaeAngle(ImageMatrix matrix, int x, int y, MinutiaType type)
{
double angle = 0;
if (type == MinutiaType.End)
{
var points = new List <Point> {
new Point(x, y)
};
for (var i = 0; i < 10; i++)
{
var 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)
{
var treeNeighboors = GetNeighboors(matrix, x, y);
if (treeNeighboors.Count < 3)
{
return(double.NaN);
}
var n1 = new List <Point> {
new Point(x, y), treeNeighboors[0]
};
var n2 = new List <Point> {
new Point(x, y), treeNeighboors[1]
};
var n3 = new List <Point> {
new Point(x, y), treeNeighboors[2]
};
for (var i = 0; i < 10; i++)
{
var 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);
}
}
var 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);
}
}
var 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);
}
var angleNeighboors1 = Angle.ComputeAngle(n1[n1.Count - 1].X - n1[0].X, n1[n1.Count - 1].Y - n1[0].Y);
var angleNeighboors2 = Angle.ComputeAngle(n2[n2.Count - 1].X - n2[0].X, n2[n2.Count - 1].Y - n2[0].Y);
var angleNeighboors3 = Angle.ComputeAngle(n3[n3.Count - 1].X - n3[0].X, n3[n3.Count - 1].Y - n3[0].Y);
var diff1 = Angle.DifferencePi(angleNeighboors1, angleNeighboors2);
var diff2 = Angle.DifferencePi(angleNeighboors1, angleNeighboors3);
var 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);
}
static void CollectMinutiae(List <MutableMinutia> minutiae, Skeleton skeleton, MinutiaType type)
{
foreach (var sminutia in skeleton.Minutiae)
{
if (sminutia.Ridges.Count == 1)
{
minutiae.Add(new MutableMinutia(sminutia.Position, sminutia.Ridges[0].Direction(), type));
}
}
}
public override void SetMinutiaType(MinutiaType type)
{
// Ignore.
}
/// <summary>
/// Initializes a new instance of the <see cref="MinutiaRecord"/> class.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="angle">The angle.</param>
/// <param name="type">The type.</param>
public MinutiaRecord(Point position, double angle, MinutiaType type)
{
m_Position = position;
m_Angle = angle;
m_Type = type;
}
public override void SetMinutiaType(MinutiaType type)
{
// Update minutia type as user has changed it.
m_Record.Type = Outer.InputMinutiaType;
}
