private object EvaluateObjectOrRetrieveFromCache(AbstractFusionObject fusionObject, string fusionPath, FusionAst fusionConfiguration, Cache.EvaluationContext cacheContext)
{
object output = null;
var evaluateObject = true;
var evaluationStatus = EvaluationStatus.Skipped;
if (runtimeContentCache.preEvaluate(cacheContext, fusionObject, out object cachedResult))
{
return(cachedResult);
}
if (!EvaluateIfCondition(fusionConfiguration, fusionPath, fusionObject))
{
evaluateObject = false;
}
if (evaluateObject)
{
output = fusionObject.Evaluate();
evaluationStatus = EvaluationStatus.Executed;
}
lastEvaluationStatus = evaluationStatus;
if (evaluateObject)
{
output = EvaluateProcessors(output, fusionConfiguration, fusionPath, fusionObject);
}
// TODO
// runtimeContentCache.postProcess(cacheContext, fusionObject, output);
return(output);
}
public static Client.EvaluationStatus ConvertEvaluationStatus(EvaluationStatus source)
{
switch (source)
{
case EvaluationStatus.InProgress:
{
return(Client.EvaluationStatus.InProgress);
}
case EvaluationStatus.Complete:
{
return(Client.EvaluationStatus.Complete);
}
case EvaluationStatus.Error:
{
return(Client.EvaluationStatus.Error);
}
default:
{
throw new ArgumentException($"Invalid value `{source}` for evaluation status was provided.", nameof(source));
}
}
}
public EvaluationTicket(EnvironmentGenome environmentGenome, List <AgentGenome> agentGenomesList, int focusPopIndex, int maxTimeSteps)
{
status = EvaluationStatus.Pending;
this.environmentGenome = environmentGenome;
this.agentGenomesList = agentGenomesList;
this.focusPopIndex = focusPopIndex;
this.maxTimeSteps = maxTimeSteps;
}
void Start()
{
eStatus = EvaluationStatus.LOADING;
PrintStatus();
Global.App_datapath = Application.dataPath;
cr_options = new ContinuousResultOptions();
cr_options.latencyFrameCount = 1;
parameters = new configuartion_parameters_t(deviceType);
knownThreshold = Global.GetDatasetThreshold(deviceType);
iteration_results = new Results();
all_results = new Results();
user_results = new Results();
//
// Load all data
//
participants = Global.GetParticipantList(deviceType);
participantsDataset = new List <Dataset>();
trainSets = new List <List <Sample> >();
participantsFrames = new List <List <Frame> >();
participantsCommands = new List <List <GestureCommand> >();
jkTrainSets = new List <List <Jackknife.Sample> >();
long ts1 = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond; // at beginning
foreach (int external_PID in participants)
{
Dataset dataset = Global.load_subject_dataset(deviceType, external_PID);
participantsDataset.Add(dataset);
List <Frame> loadedFrames = new List <Frame>();
Global.load_session(deviceType, external_PID, loadedFrames, dataset);
participantsFrames.Add(loadedFrames);
List <GestureCommand> commands = new List <GestureCommand>();
GestureCommand.GetAllCommands(commands, dataset, deviceType, external_PID);
participantsCommands.Add(commands);
List <Sample> trainSet = Global.GetTrainSet(dataset, trainCount);
trainSets.Add(trainSet);
List <Jackknife.Sample> jkTrainSet = JackknifeConnector.GetJKTrainSet(trainSet);
jkTrainSets.Add(jkTrainSet);
}
long ts2 = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond; // after loading
Debug.Log(string.Format("Loaded participants data. Time elapsed: {0}s", (ts2 - ts1) / 1000.0));
iteration = 0;
currentParticipantIndex = 0;
currentParticipantID = participants[currentParticipantIndex];
eStatus = EvaluationStatus.TRAINING;
timeStats_Overall = new RunningStatistics();
timeStats_UserDependent = new RunningStatistics();
}
/// <summary>
/// Indicates that the evaluation got canceled because of a cycle (or deadlock), and notifies any waiting threads
/// </summary>
public void Cancel(EvaluationStatus result)
{
Contract.Requires(result == EvaluationStatus.Cycle || result == EvaluationStatus.Crash);
lock (this)
{
m_result |= result;
m_event?.Set();
}
}
public dtoCriterionForEvaluation(long id, String name, int display, EvaluationStatus status, Boolean invalid)
: base()
{
Id = id;
DisplayOrder = display;
Name = name;
Status = status;
IsInvalid = invalid;
}
public CodeCellEvaluationFinishedEvent(
CodeCellId codeCellId,
EvaluationStatus status,
bool shouldStartNewCell,
IReadOnlyList <Diagnostic> diagnostics)
{
CodeCellId = codeCellId;
Status = status;
ShouldStartNewCell = shouldStartNewCell;
Diagnostics = diagnostics;
}
// public Vector3 ArenaBounds?
//public ChallengeSettingsGenome challengeSettings;
/*public EvaluationTicket(int[] genomeIndices, int focusIndex, int maxTimeSteps) {
* status = EvaluationStatus.Pending;
* //environmentRepIndex = environmentIndex;
* this.genomeIndices = genomeIndices;
* this.focusPopIndex = focusIndex;
* this.maxTimeSteps = maxTimeSteps;
* //challengeSettings = settings;
* }*/
public EvaluationTicket(EnvironmentGenome environmentGenome, List <AgentGenome> agentGenomesList, int focusIndex, int maxTimeSteps)
{
status = EvaluationStatus.Pending;
//environmentRepIndex = environmentIndex;
//this.genomeIndices = genomeIndices;
this.environmentGenome = environmentGenome;
this.agentGenomesList = agentGenomesList;
this.focusPopIndex = focusIndex;
this.maxTimeSteps = maxTimeSteps;
//challengeSettings = settings;
}
/// <summary>
/// Internal evaluation method of absolute fusionPath
/// </summary>
/// <param name="fusionPath"></param>
/// <param name="behaviorIfPathNotFound"></param>
/// <param name="contextObject">The object which will be "this" in Eel expressions, if any</param>
/// <returns></returns>
protected object EvaluateInternal(string fusionPath, FailureBehavior behaviorIfPathNotFound, AbstractFusionObject contextObject = null)
{
var needToPopContext = false;
var needToPopApply = false;
lastEvaluationStatus = EvaluationStatus.Executed;
var fusionConfiguration = GetConfigurationForPath(fusionPath);
var cacheContext = runtimeContentCache.Enter(new Cache.FusionObjectCacheConfiguration(), fusionPath);
var currentProperties = GetCurrentApplyValues();
if (currentProperties.ContainsKey(fusionPath))
{
if (!EvaluateIfCondition(fusionConfiguration, fusionPath, contextObject))
{
return(null);
}
return(EvaluateProcessors(currentProperties[fusionPath].Value, fusionConfiguration, fusionPath, contextObject));
}
if (!CanRenderWithConfiguration(fusionConfiguration))
{
FinalizePathEvaluation(cacheContext);
ThrowExceptionForUnrenderablePathIfNeeded(fusionPath, fusionConfiguration, behaviorIfPathNotFound);
lastEvaluationStatus = EvaluationStatus.Skipped;
return(null);
}
object output = null;
try
{
if (HasExpressionOrValue(fusionConfiguration))
{
return(EvaluateExpressionOrValueInternal(fusionPath, fusionConfiguration, cacheContext, contextObject));
}
needToPopApply = PrepareApplyValuesForFusionPath(fusionPath, fusionConfiguration);
var fusionObject = InstantiateFusionObject(fusionPath, fusionConfiguration);
needToPopContext = PrepareContextForFusionObject(fusionObject, fusionPath, fusionConfiguration, cacheContext);
output = EvaluateObjectOrRetrieveFromCache(fusionObject, fusionPath, fusionConfiguration, cacheContext);
}
catch (Exception e)
{
FinalizePathEvaluation(cacheContext, needToPopContext, needToPopApply);
// todo error handling
Console.WriteLine(e.Message);
// Console.WriteLine(e.StackTrace);
// throw e;
}
FinalizePathEvaluation(cacheContext, needToPopContext, needToPopApply);
return(output);
}
public object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
EvaluationResult er = new EvaluationResult();
bsonReader.ReadStartDocument();
er.Id = bsonReader.ReadObjectId();
er.DurationInSeconds = bsonReader.ReadDouble();
er.startTime = BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(bsonReader.ReadDateTime());
er.endTime = BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(bsonReader.ReadDateTime());
er.Result = EvaluationStatus.Parse(bsonReader.ReadString());
er.JSON = bsonReader.ReadString();
bsonReader.ReadEndDocument();
return(er);
}
//public dtoBaseEvaluation(Evaluation evaluation)
//{
// Deleted = evaluation.Deleted;
// Id = evaluation.Id;
// Evaluated= evaluation.Evaluated;
// IdCommittee= evaluation.Committee.Id;
// IdEvaluator= evaluation.Evaluator.Id;
// IdSubmission= evaluation.Submission.Id;
// Status= evaluation.Status;
// DisplayName = (evaluation.Submission!= null && evaluation.Submission.Owner !=null) ? evaluation.Submission.Owner.SurnameAndName : " -- ";
// Anonymous = (evaluation.Submission==null || evaluation.Submission.isAnonymous || evaluation.Submission.Owner == null);
// SubmittedOn = (evaluation.Submission!= null) ? evaluation.Submission.SubmittedOn : null;
// EvaluatorName = (evaluation.Evaluator != null && evaluation.Evaluator.Person != null) ? evaluation.Evaluator.Person.SurnameAndName : "";
// //SubmittedBy = (evaluation.Submission != null && evaluation.Submission.SubmittedBy!=null ) ? evaluation.Submission.SubmittedOn : null;
//}
public dtoBaseEvaluation(lm.Comol.Modules.CallForPapers.Domain.Evaluation.Export.expEvaluation evaluation, String anonymousDisplayName, String unknownUserName)
{
Deleted = evaluation.Deleted;
Id = evaluation.Id;
Evaluated = evaluation.Evaluated;
IdCommittee = evaluation.IdCommittee;
IdEvaluator = evaluation.IdEvaluator;
IdSubmission = evaluation.IdSubmission;
Status = evaluation.Status;
Anonymous = (evaluation.Submission == null || evaluation.Submission.isAnonymous);
DisplayName = (Anonymous) ? anonymousDisplayName : ((evaluation.Submission.Owner == null) ? unknownUserName : evaluation.Submission.Owner.SurnameAndName);
SubmittedOn = (evaluation.Submission != null) ? evaluation.Submission.SubmittedOn : null;
EvaluatorName = (evaluation.Evaluator != null && evaluation.Evaluator.Person != null) ? evaluation.Evaluator.Person.SurnameAndName : unknownUserName;
IdSubmitterType = (evaluation.Submission != null && evaluation.Submission.Type != null) ? evaluation.Submission.Type.Id : 0;
//SubmittedBy = (evaluation.Submission != null && evaluation.Submission.SubmittedBy!=null ) ? evaluation.Submission.SubmittedOn : null;
}
/// <summary>
/// Sets value and notifies any waiting threads
/// </summary>
public void SetValue(ref object value, EvaluationResult newValue)
{
// Contract.Requires(newValue != null);
lock (this)
{
// If we got canceled because of a deadlock or cycle, the only allowed value is the error value.
Contract.Assume(((m_result & EvaluationStatus.Cycle) == 0) || newValue.IsErrorValue);
// If the evaluation crashed, the only allowed value is the error value.
Contract.Assume(((m_result & EvaluationStatus.Crash) == 0) || newValue.IsErrorValue);
// If a value was already set, then we can only ever 'set' the same value again. This may happen in the case of cycles/deadlocks,
// where the error value is first set by a different thread that detected the cycle/deadlock, and then it's set again
// as the evaluation stack unwinds (minor implementation detail).
Contract.Assume(((m_result & EvaluationStatus.Value) == 0) || ((EvaluationResult)value).Value == newValue.Value);
value = newValue;
m_result |= EvaluationStatus.Value;
m_event?.Set();
}
}
internal Evaluation(
CodeCellId codeCellId,
EvaluationStatus status,
EvaluationResultHandling resultHandling,
object value,
TimeSpan evaluationDuration = default,
int cultureLCID = 0,
int uiCultureLCID = 0,
bool initializedIntegration = false,
IReadOnlyList <AssemblyDefinition> loadedAssemblies = null)
{
CodeCellId = codeCellId;
Status = status;
ResultHandling = resultHandling;
switch (value)
{
case null:
ResultRepresentations = Array.Empty <object> ();
break;
case RepresentedObject representedObject:
ResultType = representedObject.RepresentedType;
ResultRepresentations = representedObject;
break;
default:
ResultType = RepresentedType.Lookup(value.GetType());
ResultRepresentations = new [] { value };
break;
}
EvaluationDuration = evaluationDuration;
CultureLCID = cultureLCID;
UICultureLCID = uiCultureLCID;
InitializedIntegration = initializedIntegration;
LoadedAssemblies = loadedAssemblies ?? Array.Empty <AssemblyDefinition> ();
}
Evaluation(
CodeCellId codeCellId,
EvaluationStatus status,
EvaluationResultHandling resultHandling,
IRepresentedType resultType,
IReadOnlyList <object> resultRepresentations,
bool resultIsException,
TimeSpan evaluationDuration,
int cultureLCID,
int uiCultureLCID,
bool initializedIntegration,
IReadOnlyList <AssemblyDefinition> loadedAssemblies)
{
CodeCellId = codeCellId;
Status = status;
ResultHandling = resultHandling;
ResultType = resultType;
ResultRepresentations = resultRepresentations;
EvaluationDuration = evaluationDuration;
CultureLCID = cultureLCID;
UICultureLCID = uiCultureLCID;
InitializedIntegration = initializedIntegration;
LoadedAssemblies = loadedAssemblies;
}
//Private Methods:
private void DetectBegin()
{
//sets:
Plane backPlane = new Plane(InputNormal, transform.position);
//entered button volume?
foreach (var item in _evaluations)
{
//skip inactive items:
if (float.IsNegativeInfinity(item.Value.current.x))
{
continue;
}
//status:
Vector3 onPlane = backPlane.ClosestPointOnPlane(item.Value.current);
float onPlaneDistance = Vector3.Distance(transform.position, onPlane);
//within radius?
if (onPlaneDistance * 2 <= ScaledRadius)
{
//status:
Vector3 hoverPlanePosition = InputNormal * (hoverDistance + ScaledTouchDistance) + transform.position;
float zonePercentage = MathUtilities.TraveledPercentage(transform.position, hoverPlanePosition, item.Value.current);
//within zones?
if (zonePercentage >= 0 && zonePercentage <= 1)
{
_activeStatus = item.Value;
InteractionActive = true;
OnHoverBegin?.Invoke();
break;
}
}
}
}
public long GetEvaluationsCount(EvaluationStatus status)
{
return((Counters == null || !Counters.ContainsKey(status)) ? 0 : Counters[status]);
}
public dtoCommitteeEvaluationInfo()
{
Status = EvaluationStatus.None;
}
public long GetEvaluationsCount(EvaluationStatus status)
{
return(Evaluations == null ? ((long)0) : Evaluations.Where(e => e.Status == status).Count());
}
public EvaluationResult(EvaluationStatus status, string rejectionReason = "")
{
Status = status;
RejectReason = rejectionReason;
}
public void NotifyEvaluationComplete(CodeCellId targetCodeCellId, EvaluationStatus status);
public CodeCellEvaluationFinishedEvent(CodeCellId codeCellId, EvaluationStatus status, bool shouldStartNewCell, IReadOnlyList <Diagnostic> diagnostics);
protected BaseEvaluation1D()
{
_status = EvaluationStatus.None;
}
public long GetEvaluationsCount(EvaluationStatus status)
{
return Evaluations.Where(e => e.Status == status).Count();
}
void Update()
{
if (eStatus == EvaluationStatus.TRAINING)
{
if (segmentorType == SegmentorType.MACHETE)
{
Prepare();
}
else if (segmentorType == SegmentorType.WINDOW)
{
PrepareWindow();
}
eStatus = EvaluationStatus.EVALUATING;
}
if (eStatus == EvaluationStatus.EVALUATING)
{
if (frame_idx > 1)
{
// Time since last frame
timer += Time.deltaTime; // Total time
timeStats_UserDependent.add(Time.deltaTime);
timeStats_Overall.add(Time.deltaTime);
}
if (segmentorType == SegmentorType.MACHETE)
{
Step();
}
else if (segmentorType == SegmentorType.WINDOW)
{
StepWindow();
}
frame_idx += 1;
if (frame_idx == frames.Count)
{
eStatus = EvaluationStatus.SUMMARIZING;
}
}
if (eStatus == EvaluationStatus.SUMMARIZING)
{
Summarize();
eStatus = EvaluationStatus.TRANSITION;
}
if (eStatus == EvaluationStatus.TRANSITION)
{
iteration += 1;
Debug.Log(string.Format("Iteration {2} User# {0}, (Participant {1}) Completed.\n",
currentParticipantIndex, currentParticipantID, iteration));
iteration_results.PrintF();
user_results.AppendResults(iteration_results);
// PrintTimes();
iteration_results.Reset();
// If all iterations are done, continue to next participant
if (iteration == iterationCount)
{
// Save results into a file and to all results
logResultsToFile("stats.csv", user_results, timeStats_UserDependent, "PID " + currentParticipantID);
all_results.AppendResults(user_results);
iteration = 0;
currentParticipantIndex += 1;
timeStats_UserDependent.reset();
user_results.Reset();
}
// If all participants done, we're finished
if (currentParticipantIndex == participants.Count)
{
Debug.Log("FINISHED");
eStatus = EvaluationStatus.FINISHED;
all_results.PrintF();
logResultsToFile("stats.csv", all_results, timeStats_Overall, "global");
timeStats_Overall.reset();
return;
}
eStatus = EvaluationStatus.TRAINING;
}
if (eStatus == EvaluationStatus.FINISHED)
{
}
}
public void NotifyEvaluationComplete(string targetCodeCellId, EvaluationStatus status)
=> GetSession().EvaluationService.NotifyEvaluationComplete(
targetCodeCellId,
status);
static void OnCodeCellEvent(ICodeCellEvent codeCellEvent)
{
// NOTE: events may post to cells "out of order" from evaluation in
// special cases such as reactive/IObservable integrations. This is
// not handled at all in this simple console client since we just
// append to stdout. Because of this, ignore "out of order" cell
// events entirely. A real UI would render them in the correct place.
if (lastCodeCellId != default && codeCellEvent.CodeCellId != lastCodeCellId)
{
return;
}
if (codeCellEvent is CodeCellEvaluationStartedEvent)
{
StartSpinner();
}
else
{
StopSpinner();
}
switch (codeCellEvent)
{
// a full UI would set cell state to show a spinner and
// enable a button to abort the running evaluation here
case CodeCellEvaluationStartedEvent _:
break;
// and would then hide the spinner and button here
case CodeCellEvaluationFinishedEvent finishedEvent:
lastCellEvaluationStatus = finishedEvent.Status;
switch (finishedEvent.Status)
{
case EvaluationStatus.Disconnected:
RenderError("Agent was disconnected while evaluating cell");
break;
case EvaluationStatus.Interrupted:
RenderError("Evaluation was aborted");
break;
case EvaluationStatus.EvaluationException:
RenderError("An exception was thrown while evaluating cell");
break;
}
foreach (var diagnostic in finishedEvent.Diagnostics)
{
RenderDiagnostic(diagnostic);
}
break;
// and would render console output and results on the cell itself
// instead of just appending to the screen (see "out of order" note)
case CapturedOutputSegment output:
RenderOutput(output);
break;
case Evaluation result:
RenderResult(result);
break;
}
}
