protected virtual void HandleScreenEdgeReverseDirection(Sprite sprite, ITrajectory trajectory)
{
if (sprite.Bounds.Position.X < 0)
{
sprite.Bounds.Position.X += sprite.RendererData.StepX;
trajectory.Direction = Direction.Right;
OnReverseDirection(sprite, trajectory);
}
else if (sprite.Bounds.Position.X + sprite.Bounds.Size.Width > GameArea.Width)
{
sprite.Bounds.Position.X -= sprite.RendererData.StepX;
trajectory.Direction = Direction.Left;
OnReverseDirection(sprite, trajectory);
}
else if (sprite.Bounds.Position.Y < 0)
{
sprite.Bounds.Position.Y += sprite.RendererData.StepY;
trajectory.Direction = Direction.Down;
OnReverseDirection(sprite, trajectory);
}
else if (sprite.Bounds.Position.Y + sprite.Bounds.Size.Height > GameArea.Height)
{
sprite.Bounds.Position.Y -= sprite.RendererData.StepY;
trajectory.Direction = Direction.Up;
OnReverseDirection(sprite, trajectory);
}
}
private void Present(ITrajectoryBundle tb)
{
int i = 1;
foreach (ITrajectory traj in tb.Trajectories)
{
this.BeginPresentation(_datadir, traj.Name + "-" + i + ".tra");
Present(traj, i, tb.Trajectories.Count);
this.EndPresentation();
i++;
}
ITrajectory meanTraj = tb.MeanTrajectory;
ITrajectory stdTraj = tb.StdTrajectory;
ITrajectory centerTraj = tb.CentralTrajectory;
ITrajectory centerDev = tb.CentralDevTrajectory;
this.BeginPresentation(_datadir, meanTraj.Name + ".tra");
PresentMean(meanTraj, stdTraj);
this.EndPresentation();
this.BeginPresentation(_datadir, centerTraj.Name + TrajectoryBundleCollapser_CentralDTW.SUFFIX + ".tra");
PresentCenter(centerTraj, centerDev);
this.EndPresentation();
this.BeginPresentation(_gpdir, tb.Name + ".traj.gp");
CreateGnuplotScript(tb, meanTraj, centerTraj);
this.EndPresentation();
}
public ITrajectory eval(ITrajectoryBundle tb)
{
ITrajectory central = tb.CentralTrajectory;
ITrajectory dev = new Trajectory(tb.Name + SUFFIX, tb.TemporalGranularityThreshold, 0.0, 0.0);
foreach (double t in central.Times)
{
double max = Double.NegativeInfinity;
double centralval = central.eval(t);
foreach (ITrajectory traj in tb.Trajectories)
{
if (traj == central)
{
continue;
}
if (traj.Times.Count == 0)
{
continue;
}
double y = traj.eval(t);
double diff = Math.Abs(y - centralval);
if (diff > max)
{
max = diff;
}
}
dev.add(t, max);
}
return(dev);
}
private void PresentMean(ITrajectory mean, ITrajectory std)
{
string header = "# Trajectory " + mean.Name + "";
this.AppendToPresentation(header);
header = "# time mean std";
this.AppendToPresentation(header);
int count = 0;
double step = (mean.MaximumTime - mean.MinimumTime) / STEPS;
for (double x = mean.MinimumTime; x <= mean.MaximumTime; x += step) /// NULL TRAJECTORY FIX
{
double y = mean.eval(x);
double bar = std.eval(x);
string str = "" + x + "\t" + y + "\t" + bar;
this.AppendToPresentation(str);
if (step == 0.0)
{
break; /// NULL TRAJECTORY FIX
}
count++;
if (count >= STEPS)
{
break;
}
}
}
private void PresentCenter(ITrajectory center, ITrajectory dev)
{
string header = "# Trajectory " + center.Name + TrajectoryBundleCollapser_CentralDTW.SUFFIX;
this.AppendToPresentation(header);
header = "# time center dev";
this.AppendToPresentation(header);
int count = 0;
double step = (center.MaximumTime - center.MinimumTime) / STEPS;
for (double x = center.MinimumTime; x <= center.MaximumTime; x += step) /// NULL TRAJECTORY FIX
{
double ctr = center.eval(x);
double delta = dev.eval(x);
string str = "" + x + "\t" + ctr + "\t" + delta;
this.AppendToPresentation(str);
if (step == 0.0)
{
break; /// NULL TRAJECTORY FIX
}
count++;
if (count >= STEPS)
{
break;
}
}
}
private void Present(ITrajectory traj, int i, int n)
{
string header = "# Number " + i + " of " + n + "";
this.AppendToPresentation(header);
Present(traj);
}
private void Present(ITrajectory traj)
{
string header = "# Trajectory " + traj.Name + "";
this.AppendToPresentation(header);
header = "# time value";
this.AppendToPresentation(header);
int count = 0;
double step = (traj.MaximumTime - traj.MinimumTime) / STEPS;
for (double x = traj.MinimumTime; x <= traj.MaximumTime; x += step) /// NULL TRAJECTORY FIX
{
double y = traj.eval(x);
string str = "" + x + "\t" + y + "";
this.AppendToPresentation(str);
if (step == 0.0)
{
break; /// NULL TRAJECTORY FIX
}
count++;
if (count >= STEPS)
{
break;
}
}
}
public static List <ITrajectory> CalculateSolid(ITrajectory trajectory, float minAngle, float minLength, float maxLength)
{
var result = new List <ITrajectory>();
CalculateSolid(0, trajectory, trajectory.DeltaAngle, minAngle, minLength, maxLength, t => result.Add(t));
return(result);
}
public static List <Result> CalculateSolid <Result>(ITrajectory trajectory, float minAngle, float minLength, float maxLength, Func <ITrajectory, Result> calculateParts)
{
var result = new List <Result>();
CalculateSolid(0, trajectory, trajectory.DeltaAngle, minAngle, minLength, maxLength, t => result.Add(calculateParts(t)));
return(result);
}
public override void SetUpReference()
{
IPlayerInputManager inputManager = inputManagerAdaptor.GetInputManager();
thisShootingManager.SetInputManager(inputManager);
ILaunchPoint launchPoint = launchPointAdaptor.GetLaunchPoint();
thisShootingManager.SetLaunchPoint(launchPoint);
ITrajectory trajectory = trajectoryAdaptor.GetTrajectory();
thisShootingManager.SetTrajectory(trajectory);
ILandedArrowReserve landedArrowReserve = landedArrowReserveAdaptor.GetLandedArrowReserve();
thisShootingManager.SetLandedArrowReserve(landedArrowReserve);
IArrowReserve arrowReserve = arrowReserveAdaptor.GetArrowReserve();
thisShootingManager.SetArrowReserve(arrowReserve);
// IArrowTrailReserve arrowTrailReserve = arrowTrailReserveAdaptor.GetArrowTrailReserve();
// thisShootingManager.SetArrowTrailReserve(arrowTrailReserve);
ICriticalFlash flash = criticalFlashAdaptor.GetCriticalFlash();
thisShootingManager.SetCriticalFlash(flash);
IShootingDataManager shootingDataManager = shootingDataManagerAdaptor.GetShootingDataManager();
thisShootingManager.SetShootingDataManager(shootingDataManager);
}
public static MarkupStylePart CalculateSolidPart(ITrajectory trajectory, Vector3 startOffset, Vector3 endOffset, float width, Color32 color)
{
var startPosition = trajectory.StartPosition + startOffset;
var endPosition = trajectory.EndPosition + endOffset;
return(new MarkupStylePart(startPosition, endPosition, endPosition - startPosition, width, color));
}
public void RandomWalkTest()
{
Console.WriteLine("RandomWalkTest");
LoggerInitialization.SetThreshold(typeof(hurst_tests), LogLevel.Debug);
LoggerInitialization.SetThreshold(typeof(TrajectoryTransformer_Hurst), LogLevel.Info);
double y = 0.0;
ITrajectory traj = new Trajectory("data", 1.0, 0.0, 0.0);
for (double x = 0.0; x < WINDOW; x += 1.0)
{
double STEP;
if (SingletonRandomGenerator.Instance.NextDouble() <= 0.5)
{
STEP = 0.1;
}
else
{
STEP = -0.1;
}
y = y + STEP;
// traj.add(x,y);
traj.add(x, STEP);
}
ITrajectoryTransformer tx = new TrajectoryTransformer_Hurst(WINDOW, 1.0);
ITrajectory trajHurst = tx.eval(traj);
SingletonLogger.Instance().DebugLog(typeof(hurst_tests), "Hurst of RandomWalk\n");
SingletonLogger.Instance().DebugLog(typeof(hurst_tests), "" + trajHurst.ToStringLong());
}
public void LinearHurstTest()
{
Console.WriteLine("LinearHurstTest");
LoggerInitialization.SetThreshold(typeof(hurst_tests), LogLevel.Debug);
LoggerInitialization.SetThreshold(typeof(TrajectoryTransformer_Hurst), LogLevel.Debug);
double m = 0.1;
double b = 0.0;
ITrajectory traj = new Trajectory("data", 1.0, 0.0, 0.0);
double INC = 1.0;
for (double x = 0.0; x < WINDOW; x += INC)
{
double NOISE_SCALE = 0.0001;
double noise = 2.0 * NOISE_SCALE * SingletonRandomGenerator.Instance.NextDouble() - NOISE_SCALE;
double y = m * INC + noise;
traj.add(x, y);
}
ITrajectoryTransformer tx = new TrajectoryTransformer_Hurst(WINDOW, 1.0);
ITrajectory trajHurst = tx.eval(traj);
SingletonLogger.Instance().DebugLog(typeof(hurst_tests), "Hurst of y = " + m + " x + " + b + "\n");
SingletonLogger.Instance().DebugLog(typeof(hurst_tests), "" + trajHurst.ToStringLong());
}
public void RandomBinaryTest()
{
Console.WriteLine("RandomBinaryTest");
LoggerInitialization.SetThreshold(typeof(hurst_tests), LogLevel.Debug);
LoggerInitialization.SetThreshold(typeof(TrajectoryTransformer_Hurst), LogLevel.Debug);
double y = 0.0;
ITrajectory traj = new Trajectory("data", 1.0, 0.0, 0.0);
bool pos = true;
for (double x = 0.0; x < WINDOW; x += 1.0)
{
if (pos)
{
y = 1.0;
traj.add(x, y);
pos = false;
}
else
{
y = -1.0;
traj.add(x, y);
pos = true;
}
}
ITrajectoryTransformer tx = new TrajectoryTransformer_Hurst(WINDOW, 1.0);
ITrajectory trajHurst = tx.eval(traj);
SingletonLogger.Instance().DebugLog(typeof(hurst_tests), "Hurst of Random Alternating\n");
SingletonLogger.Instance().DebugLog(typeof(hurst_tests), "" + trajHurst.ToStringLong());
}
protected virtual IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory trajectory, float startT, float endT, LineBorders borders)
{
if (StyleHelper.CalculateDashedParts(borders, trajectory, startT, endT, DashLength, 0, Width, Color, out MarkupStylePart dash))
{
yield return(dash);
}
}
public bool GetBordersLine(Enter first, Enter second, out ITrajectory line)
{
var i = EntersList.IndexOf(first);
var j = EntersList.IndexOf(second);
return(BetweenEnters.TryGetValue(i, j, out line));
}
public static List <MarkupIntersect> Calculate(ITrajectory trajectory1, ITrajectory trajectory2)
{
if (trajectory1 != null && trajectory2 != null)
{
if (trajectory1.TrajectoryType == TrajectoryType.Bezier)
{
if (trajectory2.TrajectoryType == TrajectoryType.Bezier)
{
return(Calculate(trajectory1 as BezierTrajectory, trajectory2 as BezierTrajectory));
}
else if (trajectory2.TrajectoryType == TrajectoryType.Line)
{
return(Calculate(trajectory1 as BezierTrajectory, trajectory2 as StraightTrajectory));
}
}
else if (trajectory1.TrajectoryType == TrajectoryType.Line)
{
if (trajectory2.TrajectoryType == TrajectoryType.Bezier)
{
return(Calculate(trajectory1 as StraightTrajectory, trajectory2 as BezierTrajectory));
}
else if (trajectory2.TrajectoryType == TrajectoryType.Line)
{
return(Calculate(trajectory1 as StraightTrajectory, trajectory2 as StraightTrajectory));
}
}
}
return(new List <MarkupIntersect>());
}
public double eval(ITrajectory traj1, ITrajectory traj2, double t)
{
if ((_traj1 != traj1) || (_traj2 != traj2))
{
double dt1 = (traj1.MaximumTime - traj1.MinimumTime) / (double)TIME_GRID;
double dt2 = (traj2.MaximumTime - traj2.MinimumTime) / (double)TIME_GRID;
_dt = Math.Min(dt1, dt2);
int w = (int)(WARP_TIME_SECONDS / _dt);
computeDTWArray(traj1, traj2, TIME_GRID, w);
}
int index1 = (int)(t / _dt);
int i = TIME_GRID - 1;
int j = TIME_GRID - 1;
while (i > index1)
{
if (_move[i, j] == 'x')
{
i = i - 1;
}
if (_move[i, j] == 'y')
{
j = j - 1;
}
if (_move[i, j] == 'b')
{
i = i - 1; j = j - 1;
}
}
return(traj1.eval(_dt * (double)i) - traj2.eval(_dt * (double)j));
}
public void Divide(out ITrajectory trajectory1, out ITrajectory trajectory2)
{
var middle = (Trajectory.a + Trajectory.b) / 2;
trajectory1 = new StraightTrajectory(Trajectory.a, middle);
trajectory2 = new StraightTrajectory(middle, Trajectory.b);
}
protected IEnumerable <MarkupStylePart> CalculateCroswalkPart(ITrajectory trajectory, float startT, float endT, Vector3 direction, ITrajectory[] borders, float length, float width, Color32 color)
{
var position = trajectory.Position((startT + endT) / 2);
var partTrajectory = new StraightTrajectory(position, position + direction, false);
var intersects = Intersection.Calculate(partTrajectory, borders, true);
intersects = intersects.OrderBy(i => i.FirstT).ToList();
var halfLength = length / 2;
var halfWidth = width / 2;
for (var i = 1; i < intersects.Count; i += 2)
{
var startOffset = GetOffset(intersects[i - 1], halfWidth);
var endOffset = GetOffset(intersects[i], halfWidth);
var start = Mathf.Clamp(intersects[i - 1].FirstT + startOffset, -halfLength, halfLength);
var end = Mathf.Clamp(intersects[i].FirstT - endOffset, -halfLength, halfLength);
var delta = end - start;
if (delta < 0.9 * length && delta < 0.67 * width)
{
continue;
}
var startPosition = position + direction * start;
var endPosition = position + direction * end;
yield return(new MarkupStylePart(startPosition, endPosition, direction, width, color));
}
}
public ITrajectory Get(TrajectoryType trajectoryType)
{
ITrajectory trajectory = null;
traj.TryGetValue((int)trajectoryType, out trajectory);
return(trajectory);
}
public ITrajectory eval(ITrajectory traj1, ITrajectory traj2)
{
if ((_traj1 != traj1) || (_traj2 != traj2))
{
double dt1 = (traj1.MaximumTime - traj1.MinimumTime) / (double)TIME_GRID;
double dt2 = (traj2.MaximumTime - traj2.MinimumTime) / (double)TIME_GRID;
_dt = Math.Min(dt1, dt2);
int w = (int)(WARP_TIME_SECONDS / _dt);
computeDTWArray(traj1, traj2, TIME_GRID, w);
}
Trajectory traj = new Trajectory(traj1.Name + "-" + traj2.Name, 0.0, 0.0, 0.0);
int i = TIME_GRID - 1;
int j = TIME_GRID - 1;
while ((i != 0) || (j != 0))
{
traj.add(_dt * (double)i, traj1.eval(_dt * (double)i) - traj2.eval(_dt * (double)j));
if (_move[i, j] == 'x')
{
i = i - 1;
}
if (_move[i, j] == 'y')
{
j = j - 1;
}
if (_move[i, j] == 'b')
{
i = i - 1; j = j - 1;
}
}
return(traj);
}
public static IEnumerable <MarkupStylePart> CalculateDashed(ITrajectory trajectory, float dashLength, float spaceLength, DashedGetter calculateDashes)
{
List <PartT> partsT;
switch (trajectory)
{
case BezierTrajectory bezierTrajectory:
partsT = CalculateDashesBezierT(bezierTrajectory, dashLength, spaceLength);
break;
case StraightTrajectory straightTrajectory:
partsT = CalculateDashesStraightT(straightTrajectory, dashLength, spaceLength);
break;
default:
yield break;
}
foreach (var partT in partsT)
{
foreach (var part in calculateDashes(trajectory, partT.Start, partT.End))
{
yield return(part);
}
}
}
protected override IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory trajectory, LineBorders borders)
{
var firstOffset = Alignment.Value switch
{
Manager.Alignment.Left => 2 * Offset,
Manager.Alignment.Centre => Offset,
Manager.Alignment.Right => 0,
_ => 0,
};
var secondOffset = Alignment.Value switch
{
Manager.Alignment.Left => 0,
Manager.Alignment.Centre => - Offset,
Manager.Alignment.Right => - 2 * Offset,
_ => 0,
};
if (StyleHelper.CalculateSolidPart(borders, trajectory, firstOffset, Width, Color, out MarkupStylePart firstDash))
{
yield return(firstDash);
}
if (StyleHelper.CalculateSolidPart(borders, trajectory, secondOffset, Width, Color, out MarkupStylePart secondDash))
{
yield return(secondDash);
}
}
protected override IStyleData Calculate(MarkupRegularLine line, ITrajectory trajectory, MarkupLOD lod)
{
var solidOffset = CenterSolid ? 0 : Invert ? Offset : -Offset;
var dashedOffset = (Invert ? -Offset : Offset) * (CenterSolid ? 2 : 1);
var borders = line.Borders;
var dashes = new List <MarkupStylePart>();
dashes.AddRange(StyleHelper.CalculateSolid(trajectory, lod, CalculateSolidDash));
if (CheckDashedLod(lod, Width, DashLength))
{
dashes.AddRange(StyleHelper.CalculateDashed(trajectory, DashLength, SpaceLength, CalculateDashedDash));
}
return(new MarkupStyleParts(dashes));
IEnumerable <MarkupStylePart> CalculateSolidDash(ITrajectory lineTrajectory)
{
if (StyleHelper.CalculateSolidPart(borders, lineTrajectory, solidOffset, Width, Color, out MarkupStylePart dash))
{
yield return(dash);
}
}
IEnumerable <MarkupStylePart> CalculateDashedDash(ITrajectory lineTrajectory, float startT, float endT)
{
if (StyleHelper.CalculateDashedParts(borders, lineTrajectory, startT, endT, DashLength, dashedOffset, Width, Color, out MarkupStylePart dash))
{
yield return(dash);
}
}
}
protected virtual IEnumerable <MarkupStylePart> CalculateDashes(ITrajectory trajectory, LineBorders borders)
{
if (StyleHelper.CalculateSolidPart(borders, trajectory, 0f, Width, Color, out MarkupStylePart dash))
{
yield return(dash);
}
}
public MarkupStyleLineMesh(ITrajectory trajectory, float width, float elevation, MaterialType materialType) : base(HalfWidth * 2f, HalfLength * 2f)
{
var position = (trajectory.StartPosition + trajectory.EndPosition) / 2;
CalculateMatrix(trajectory, width, position, out Matrix4x4 left, out Matrix4x4 right);
position += Vector3.up * (elevation - Height);
Init(position, left, right, materialType);
}
private void computeDTWArray(ITrajectory traj1, ITrajectory traj2, int n, int w)
{
double [] s = TrajectoryToArray(traj1, n);
double [] t = TrajectoryToArray(traj2, n);
DTWDistance(s, t, w);
_traj1 = traj1;
_traj2 = traj2;
}
protected override IStyleData Calculate(MarkupStopLine stopLine, ITrajectory trajectory, MarkupLOD lod)
{
var offset = ((stopLine.Start.Direction + stopLine.End.Direction) / -2).normalized * (Width / 2);
return(new MarkupStyleParts(StyleHelper.CalculateSolid(trajectory, lod, CalculateDashes)));
MarkupStylePart CalculateDashes(ITrajectory dashTrajectory) => StyleHelper.CalculateSolidPart(dashTrajectory, offset, offset, Width, Color);
}
protected override IStyleData Calculate(MarkupRegularLine line, ITrajectory trajectory, MarkupLOD lod)
{
var borders = line.Borders;
return(new MarkupStyleParts(StyleHelper.CalculateSolid(trajectory, lod, GetDashes)));
IEnumerable <MarkupStylePart> GetDashes(ITrajectory trajectory) => CalculateDashes(trajectory, borders);
}
