public IntervalSnapshots CalculateSnapshots(Person person)
{
if (person.IsSnapshotsKnown)
{
return(person.Snapshots);
}
//start on first day at 00:00:00
if (person.StartFrom == new DateTime())
{
DateTime d = person.ActivePalEvents.ToList().First().Date;
person.StartFrom = new DateTime(d.Year, d.Month, d.Day);
}
//end on the last day at 00:00:00
if (person.StopAt == new DateTime())
{
DateTime d = person.ActivePalEvents.ToList().Last().Date;
person.StopAt = new DateTime(d.Year, d.Month, d.Day);
}
//IRecordConverter converter = new PalRecordsConverter(CheckpointRate);
IntervalSnapshots result = recordConverter
.ToCheckpointRecords(
person.ActivePalEvents,
person.StartFrom,
person.StopAt,
person.CheckpointRate);
person.Snapshots = result;
person.IsSnapshotsKnown = true;
return(person.Snapshots);
}
public string Save(IntervalSnapshots snapshots,
string toFilePath,
bool asOneLineString = false,
bool saveJustEventCodes = false,
bool shoulAppend = false,
string separator = ", ")
{
IEnumerable <int> activityCodes = snapshots.Data.Select(
record =>
(int)record.ActivityCode);
csvWriter.Separator = separator;
if (asOneLineString)
{
csvWriter.WriteData(activityCodes, toFilePath, true);
}
else
{
if (saveJustEventCodes)
{
csvWriter.WriteData(activityCodes, toFilePath);
}
else
{
csvWriter.WriteData(snapshots.Data, toFilePath);
}
}
return(Path.GetFullPath(toFilePath));
}
private EntropyResult CalculateEntropy(DateTime start, DateTime stop, TimeSpan interval)
{
recordConverter.ActivityCheck = interval;
var events = GetEvents(subjectFile);
IntervalSnapshots checkpoints = recordConverter.ToCheckpointRecords(
events,
start,
stop,
interval);
var entropy = new Entropy();
return(entropy.CalculateShannonEntropy(checkpoints, alphabet.GetAlphabet()));
}
public string SaveSnapshots(Person person, string toFilePath,
bool asOneLineString = false,
bool saveJustEventCodes = false,
string separator = ", ")
{
if (String.IsNullOrEmpty(toFilePath))
{
toFilePath = String.Concat(person.Id, "outputSnapshots.csv");
}
IntervalSnapshots snapshots = calculationService.CalculateSnapshots(person);
string output = snapService.Save(snapshots, toFilePath, asOneLineString,
saveJustEventCodes, separator: separator);
return(output);
}
public double CalculateCompressionRate(Person person, CompressionType compressionType
= CompressionType.Gzip)
{
if (person.CompressionRate != null)
{
return((double)person.CompressionRate);
}
IntervalSnapshots snapshots = CalculateSnapshots(person);
string suffix = ConfigurationManager.AppSettings["snapshotTextOutput"];
string toUncompressedPath = String.Concat(person.Id, suffix);
double rate = GetCompressionRate(toUncompressedPath, snapshots.Data, compressionType);
person.CompressionRate = rate;
return(rate);
}
public IEnumerable <IntervalSnapshots> CalculateDailySnapshots(
Person person,
TimeSpan startTime,
TimeSpan stopTime,
int skipFirsDays = 0,
int skipLastDay = 0)
{
var daysSnapshots = new List <IntervalSnapshots>();
//first record date
DateTime date = person.ActivePalEvents.ToList().First().Date.AddDays(skipFirsDays);
var startDate = new DateTime(date.Year, date.Month, date.Day,
startTime.Hours, startTime.Minutes,
startTime.Seconds, startTime.Milliseconds);
var stopDate = new DateTime(date.Year, date.Month, date.Day,
stopTime.Hours, stopTime.Minutes,
stopTime.Seconds, stopTime.Milliseconds);
//last date record
date = person.ActivePalEvents.ToList().Last().Date;
var fullStopDate = new DateTime(date.Year, date.Month, date.Day - skipLastDay);
while (stopDate < fullStopDate)
{
//IRecordConverter converter = new PalRecordsConverter(CheckpointRate);
IntervalSnapshots daySnap = recordConverter
.ToCheckpointRecords(
person.ActivePalEvents,
startDate,
stopDate,
person.CheckpointRate);
daysSnapshots.Add(daySnap);
startDate = startDate.AddDays(1);
stopDate = stopDate.AddDays(1);
}
return(daysSnapshots);
}
public override IntervalSnapshots ToCheckpointRecords(IEnumerable <EventRecord> events,
DateTime start, DateTime stop, TimeSpan activityCheck)
{
var snapshots = new IntervalSnapshots();
List <Record> data = snapshots.Data.ToList();
//create a list of checkpoints from the start date to the final record
ICheckpointFactory factory = new CheckpointFactory();
var defaultCheckpoints = factory.CreateRecords(start, stop, activityCheck);
//TODO can be improved by trimming the whole list from sides
List <EventRecord> palEvents = events.ToList();
int pointer = 0;
int palEventCount = events.Count();
EventRecord firstIntervalRecord = null;
EventRecord lastIntervalRecord = null;
//for every default blunt checkpoint
defaultCheckpoints.ToList().ForEach(
checkPoint
=>
{
//get currentRecord date
DateTime checkPointDate = checkPoint.Date;
//while pointer is less the count
while (pointer < palEventCount)
{
EventRecord palEvent = palEvents[pointer];
DateTime end = palEvent.Date + palEvent.Duration;
//if event date stretches thoough the checkpoint
if (end > checkPointDate)
{
//set first record in the interval
if (firstIntervalRecord == null)
{
firstIntervalRecord = palEvent;
}
//will leave the last record after looping
lastIntervalRecord = palEvent;
//remember activity code
checkPoint.ActivityCode = palEvent.ActivityCode;
data.Add(checkPoint);
break;
}
pointer += 1;
}
}
);
snapshots.Data = data;
snapshots.StartDate = start;
snapshots.FinishDate = stop;
if (lastIntervalRecord != null && firstIntervalRecord != null)
{
snapshots.CumulativeStepCount = lastIntervalRecord.CumulativeStepCount -
firstIntervalRecord.CumulativeStepCount;
}
return(snapshots);
}
