private void FindNeighbours_List_Recursion(int index, int level, CounterClass myClass)
{
try
{
if (level == 0)
{
return;
}
System.Collections.Generic.LinkedListNode <int> counter = AdjacencyList[index].First;
while (counter != null)
{
myClass.neighbours[myClass.counter] = counter.Value;
myClass.counter++;
FindNeighbours_List_Recursion(counter.Value, level - 1, myClass);
counter = counter.Next;
}
}
catch (NullReferenceException nre)
{
System.Console.WriteLine(nre.StackTrace);
System.Console.WriteLine(nre.Message);
}
catch (IndexOutOfRangeException ior)
{
System.Console.WriteLine(ior.StackTrace);
System.Console.WriteLine(ior.Message);
}
}
public int[] FindNeighbours_List(int index, int level)
{
try
{
CounterClass myClass = new CounterClass
{
counter = 0,
neighbours = new int[GraphSize]
};
FindNeighbours_List_Recursion(index, level, myClass);
return(myClass.neighbours.Distinct <int>().ToArray <int>());
//return myClass.neighbours;
}
catch (NullReferenceException nre)
{
System.Console.WriteLine(nre.StackTrace);
System.Console.WriteLine(nre.Message);
return(null);
}
catch (IndexOutOfRangeException ior)
{
System.Console.WriteLine(ior.StackTrace);
System.Console.WriteLine(ior.Message);
return(null);
}
}
public int[] FindNeighbours_Matrix(int index, int level)
{
CounterClass myClass = new CounterClass();
myClass.counter = 0;
myClass.neighbours = new int[20];
FindNeighbours_Matrix_Recursion(index, level, myClass);
return(myClass.neighbours);
}
private void FindNeighbours_Matrix_Recursion(int index, int level, CounterClass myClass)
{
if (level == 0)
{
return;
}
level--;
for (int i = 0; i < AdjacentMatrix.GetLength(1); i++)
{
if (AdjacentMatrix[index, i] == 1)
{
myClass.neighbours[myClass.counter] = ArrVertices[i];
myClass.counter++;
FindNeighbours_Matrix_Recursion(i, level, myClass);
}
}
}
public HomeController(CounterClass counter)
{
this.counter = counter;
}
private void GenerateIndivResultsFinal()
{
int rows = 1000;
int columns = 22;
object[,] data = new object[rows, columns];
int rowCounter = 1;
data[0, 0] = "Mouse";
data[0, 1] = "Type";
data[0, 2] = "Age";
data[0, 3] = "Clip";
data[0, 4] = "Centroid Width";
data[0, 5] = "Distance";
data[0, 6] = "Max Velocity";
data[0, 7] = "Max Angular Velocity";
data[0, 8] = "Average Velocity";
data[0, 9] = "Average Angular Velocity";
data[0, 10] = "Average Pelvic Area 1";
data[0, 11] = "Average Pelvic Area 2";
data[0, 12] = "Average Pelvic Area 3";
data[0, 13] = "Average Pelvic Area 4";
data[0, 14] = "Average Centroid Velocity";
data[0, 15] = "Max Centroid Velocity";
data[0, 16] = "Clip Duration";
data[0, 17] = "Percentage Running";
data[0, 18] = "Percentage moving";
data[0, 19] = "Percentage turning";
data[0, 20] = "Percentage Still";
data[0, 21] = "Percentage Interacting";
Dictionary <BatchProcessViewModel.BrettTuple <string, int>, IMouseDataResult> sortedResults = new Dictionary <BatchProcessViewModel.BrettTuple <string, int>, IMouseDataResult>();
Dictionary <BatchProcessViewModel.BrettTuple <string, int>, CounterClass> sortedCounters = new Dictionary <BatchProcessViewModel.BrettTuple <string, int>, CounterClass>();
List <MouseHolder> mice = new List <MouseHolder>();
foreach (SingleMouseViewModel mouse in Videos)
{
mice.AddRange(from video in mouse.VideoFiles let result = mouse.Results[video] select new MouseHolder()
{
Age = mouse.Age.ToString(), Class = mouse.Class, File = video.VideoFileName, Mouse = mouse, Result = result, Type = mouse.Type.Name
});
}
try
{
foreach (MouseHolder mouse in mice)
{
BatchProcessViewModel.BrettTuple <string, int> key = new BatchProcessViewModel.BrettTuple <string, int>(mouse.Mouse.Id, mouse.Mouse.Age);
IMouseDataResult finalResult;
CounterClass counter;
if (sortedResults.ContainsKey(key))
{
finalResult = sortedResults[key];
counter = sortedCounters[key];
}
else
{
finalResult = ModelResolver.Resolve <IMouseDataResult>();
finalResult.Name = mouse.Mouse.Id;
finalResult.Age = mouse.Mouse.Age;
finalResult.Type = mouse.Mouse.Type;
counter = new CounterClass();
sortedResults.Add(key, finalResult);
sortedCounters.Add(key, counter);
}
IMouseDataResult result = mouse.Result;
if (result.EndFrame - result.StartFrame < 100)
{
continue;
}
double centroidWidth = result.GetCentroidWidthForRunning();
double distanceTravelled = result.DistanceTravelled;
double maxSpeed = result.MaxSpeed;
double maxAngVelocity = result.MaxAngularVelocty;
double avgVelocity = result.GetAverageSpeedForMoving();
double averageAngVelocity = result.AverageAngularVelocity;
double avgPelvic1 = result.GetCentroidWidthForPelvic1();
double avgPelvic2 = result.GetCentroidWidthForPelvic2();
double avgPelvic3 = result.GetCentroidWidthForPelvic3();
double avgPelvic4 = result.GetCentroidWidthForPelvic4();
double avgCentroidVelocity = result.GetAverageCentroidSpeedForMoving();
double maxCentroidVelocity = result.MaxCentroidSpeed;
double duration = result.EndFrame - result.StartFrame;
avgVelocity /= 1000;
avgCentroidVelocity /= 1000;
maxSpeed /= 1000;
maxCentroidVelocity /= 1000;
averageAngVelocity /= 1000;
maxAngVelocity /= 1000;
int frameDelta = result.EndFrame - result.StartFrame;
List <Tuple <int, int> > movingFrameNumbers = result.GetFrameNumbersForMoving();
List <Tuple <int, int> > runningFrameNumbers = result.GetFrameNumbersForRunning();
List <Tuple <int, int> > turningFrameNumbers = result.GetFrameNumbersForTurning();
List <Tuple <int, int> > stillFrameNumbers = result.GetFrameNumbersForStill();
List <Tuple <int, int> > interactingFrameNumbers = result.GetFrameNumbesrForInteracting();
int movingFrameCount = 0, runningFrameCount = 0, turningFrameCount = 0, stillFrameCount = 0;
if (movingFrameNumbers != null && movingFrameNumbers.Any())
{
foreach (Tuple <int, int> t in movingFrameNumbers)
{
int delta = t.Item2 - t.Item1;
movingFrameCount += delta;
}
}
if (runningFrameNumbers != null && runningFrameNumbers.Any())
{
foreach (Tuple <int, int> t in runningFrameNumbers)
{
int delta = t.Item2 - t.Item1;
runningFrameCount += delta;
}
}
if (stillFrameNumbers != null && stillFrameNumbers.Any())
{
foreach (Tuple <int, int> t in stillFrameNumbers)
{
int delta = t.Item2 - t.Item1;
stillFrameCount += delta;
}
}
if (turningFrameNumbers != null && turningFrameNumbers.Any())
{
foreach (Tuple <int, int> t in turningFrameNumbers)
{
int delta = t.Item2 - t.Item1;
turningFrameCount += delta;
}
}
List <int> allInteractingFrameNumbers = new List <int>();
if (interactingFrameNumbers != null && interactingFrameNumbers.Any())
{
foreach (Tuple <int, int> t in interactingFrameNumbers)
{
int start = t.Item1;
int end = t.Item2;
for (int i = start; i <= end; i++)
{
if (!allInteractingFrameNumbers.Contains(i))
{
allInteractingFrameNumbers.Add(i);
}
}
}
}
double movingPercentage = (double)movingFrameCount / frameDelta;
double runningPercentage = (double)runningFrameCount / frameDelta;
double turningPercentage = (double)turningFrameCount / frameDelta;
double stillPercentage = (double)stillFrameCount / frameDelta;
int fCount = allInteractingFrameNumbers.Count - 1;
if (fCount < 0)
{
fCount = 0;
}
double interactionPercentage = (double)fCount / frameDelta;
if (centroidWidth > 0)
{
finalResult.CentroidSize += centroidWidth;
counter.CentroidWidth++;
}
if (distanceTravelled > 0)
{
finalResult.DistanceTravelled += distanceTravelled;
counter.Distance++;
}
if (maxSpeed > 0)
{
if (maxSpeed > finalResult.MaxSpeed)
{
finalResult.MaxSpeed = maxSpeed;
}
//counter.MaxVelocity++;
}
if (maxAngVelocity > 0)
{
if (maxAngVelocity > finalResult.MaxAngularVelocty)
{
finalResult.MaxAngularVelocty = maxAngVelocity;
}
//counter.MaxAngVelocity++;
}
if (avgVelocity > 0)
{
finalResult.AverageVelocity += avgVelocity;
counter.AvgVelocity++;
}
if (averageAngVelocity > 0)
{
finalResult.AverageAngularVelocity += averageAngVelocity;
counter.AvgAngVelocity++;
}
if (avgPelvic1 > 0)
{
finalResult.PelvicArea += avgPelvic1;
counter.AvgPelvic1++;
}
if (avgPelvic2 > 0)
{
finalResult.PelvicArea2 += avgPelvic2;
counter.AvgPelvic2++;
}
if (avgPelvic3 > 0)
{
finalResult.PelvicArea3 += avgPelvic3;
counter.AvgPelvic3++;
}
if (avgPelvic4 > 0)
{
finalResult.PelvicArea4 += avgPelvic4;
counter.AvgPelvic4++;
}
if (avgCentroidVelocity > 0)
{
finalResult.AverageCentroidVelocity += avgCentroidVelocity;
counter.AvgCentroidVelocity++;
}
if (maxCentroidVelocity > 0)
{
if (maxCentroidVelocity > finalResult.MaxCentroidSpeed)
{
finalResult.MaxCentroidSpeed += maxCentroidVelocity;
}
//counter.MaxCentroidVelocity++;
}
//if (duration > 0)
//{
finalResult.Duration += duration;
counter.ClipDuration++;
//}
//if (runningPercentage > 0)
//{
finalResult.Dummy += runningPercentage;
counter.PercentageRunning++;
//}
//if (movingPercentage > 0)
//{
finalResult.Dummy2 += movingPercentage;
counter.PercentageMoving++;
//}
//if (turningPercentage > 0)
//{
finalResult.Dummy3 += turningPercentage;
counter.PercentageTurning++;
//}
//if (stillPercentage > 0)
//{
finalResult.Dummy4 += stillPercentage;
counter.PercentageStill++;
//}
finalResult.Dummy5 += interactionPercentage;
counter.PercentageInteracting++;
//rowCounter++;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
string fileLocation = FileBrowser.SaveFile("Excel CSV|*.csv");
if (string.IsNullOrWhiteSpace(fileLocation))
{
return;
}
foreach (var kvp in sortedResults)
{
var key = kvp.Key;
var counter = sortedCounters[key];
IMouseDataResult result = kvp.Value;
data[rowCounter, 0] = result.Name;
data[rowCounter, 1] = result.Type;
data[rowCounter, 2] = result.Age;
//data[rowCounter, 3] = "Clip";
data[rowCounter, 4] = result.CentroidSize / counter.CentroidWidth;
data[rowCounter, 5] = result.DistanceTravelled / counter.Distance;
data[rowCounter, 6] = result.MaxSpeed;
data[rowCounter, 7] = result.MaxAngularVelocty;
data[rowCounter, 8] = result.AverageVelocity / counter.AvgVelocity;
data[rowCounter, 9] = result.AverageAngularVelocity / counter.AvgAngVelocity;
data[rowCounter, 10] = result.PelvicArea / counter.AvgPelvic1;
data[rowCounter, 11] = result.PelvicArea2 / counter.AvgPelvic2;
data[rowCounter, 12] = result.PelvicArea3 / counter.AvgPelvic3;
data[rowCounter, 13] = result.PelvicArea4 / counter.AvgPelvic4;
data[rowCounter, 14] = result.AverageCentroidVelocity / counter.AvgCentroidVelocity;
data[rowCounter, 15] = result.MaxSpeed;
data[rowCounter, 16] = result.Duration / counter.ClipDuration;
data[rowCounter, 17] = result.Dummy / counter.PercentageRunning;
data[rowCounter, 18] = result.Dummy2 / counter.PercentageMoving;
data[rowCounter, 19] = result.Dummy3 / counter.PercentageTurning;
data[rowCounter, 20] = result.Dummy4 / counter.PercentageStill;
data[rowCounter, 21] = result.Dummy5 / counter.PercentageInteracting;
rowCounter++;
}
int rowCount = data.GetLength(0);
int columnCount = data.GetLength(1);
StringBuilder sb = new StringBuilder();
for (int i = 1; i <= rowCount; i++)
{
StringBuilder sb2 = new StringBuilder();
for (int j = 1; j <= columnCount; j++)
{
object dat = data[i - 1, j - 1];
sb2.Append(dat);
if (j < columnCount)
{
sb2.Append(",");
}
}
sb.AppendLine(sb2.ToString());
}
using (System.IO.StreamWriter file = new System.IO.StreamWriter(fileLocation))
{
file.WriteLine(sb.ToString());
}
}
