private List <RefPoint> getRefPoints(Trajectory trj) { if (trj.Count == 0) { return(null); } List <RefPoint> refPoints = new List <RefPoint>(); for (int i = 0; i < trj.Count; ++i) { MotionVector mv = trj[i]; RefPoint refPoint = null; if (mv.e != null) { double distance = mv.e.DistOnLine(mv.e.Start.Point, mv.point); refPoint = new RefPoint(mv.t, mv.e, distance); } else { refPoint = new RefPoint(mv.t, mv.point); } refPoints.Add(refPoint); } // calcualte the deviation between trj and the ref points //String tempFileName = Path.Combine(Constants.TRJ_DIR, "1000099465_short_ref"); //StreamWriter sw = new StreamWriter(tempFileName); //for (int i = 0; i < trj.Count; ++i) //{ // MotionVector mv = trj[i]; // double dev = GeoPoint.GetDistance(mv.point, refPoints[i].Point); // sw.WriteLine("{0},{1},{2},{3},{4}", mv.t, mv.point.Lat, mv.point.Lng, mv.EdgeId, dev); //} //sw.Close(); return(refPoints); }
void ShowValues() { if (Phone == null) { return; } var acc = new MotionVector { X = Phone.RotationX / 360, Y = Phone.RotationY / 360, Z = Phone.Rotation / 360, }; // TODO: For gyro, this should be the speed, not present value. // We should find a time-based approach to find the correct values. var gyro = new MotionVector { X = Phone.RotationX / 360, Y = Phone.RotationY / 360, Z = Phone.Rotation / 360, }; AccelerometerInfo.Text($"Accelorometer X: {acc.X.Round(2)} Y: {acc.Y.Round(2)} Z: {acc.Z.Round(2)}"); GyroscopeInfo.Text($"Gyroscope X: {gyro.X.Round(2)} Y: {gyro.Y.Round(2)} Z: {gyro.Z.Round(2)}"); CompassInfo.Text($"Compass Heading: {acc.Z.Round(2)}"); }
//============================================= //End reference C1 //============================================= // This method checks to see if the device was shaken by calling WasTheDeviceShaken // and if so it clears the text field. private void ClearTextField(MotionVector value) { if (WasTheDeviceShaken(value)) { this.entryField.Text = ""; } }
/// <summary> /// Check if the line formed by startIdx.point and endIdx.point can represents internal motion vectors /// </summary> /// <param name="startIdx"></param> /// <param name="endIdx"></param> /// <returns></returns> private bool canApproximate(int startIdx, int endIdx) { bool result = true; if (endIdx - startIdx <= 1) { return(result); } MotionVector start = trj[startIdx], end = trj[endIdx]; GeoPoint pStart = start.point, pEnd = end.point; double baseLat, baseLng; baseLat = (pEnd.Lat - pStart.Lat) / (end.t - start.t); baseLng = (pEnd.Lng - pStart.Lng) / (end.t - start.t); for (int i = startIdx + 1; i < endIdx; i++) { double lat, lng; double dev2; MotionVector middle = trj[i]; lat = baseLat * (middle.t - start.t) + pStart.Lat; lng = baseLng * (middle.t - start.t) + pStart.Lng; dev2 = GeoPoint.GetDistance2(new GeoPoint(lat, lng), middle.point); //Debug.Assert(middle.e != null); if (dev2 > maxDev * maxDev) { result = false; break; } } return(result); }
/// <summary> /// Event that occurs when a sensor value changes. /// </summary> /// <param name="sensorEvent">Sensor event</param> public void OnSensorChanged(SensorEvent sensorEvent) { if (sensorEvent.Values.Count == 1) { var value = sensorEvent.Values[0]; switch (sensorEvent.Sensor.Type) { case AndroidSensorType.Light: _sensors.EmitLightLevel(value); break; } } // In this case, the sensor is likely a vector. else if (sensorEvent.Values.Count == 3) { var vector = new MotionVector(sensorEvent.Values[0], sensorEvent.Values[1], sensorEvent.Values[2]); switch (sensorEvent.Sensor.Type) { case AndroidSensorType.Accelerometer: _sensors.EmitAccelerometer(vector); break; case AndroidSensorType.Gyroscope: _sensors.EmitGyroscope(vector); break; case AndroidSensorType.RotationVector: _sensors.EmitDeviceMotion(vector); break; } } }
void IUpdateable.Update(TimeSpan elapsedInFrame) { FrameStartPosition = ObjectToMove.Position.Copy(); foreach (var adjuster in MotionAdjusters) { adjuster.Update(ObjectToMove, MotionVector); } foreach (var multiplier in MotionMultipliers) { MotionVector.X.TargetScale = multiplier.GetTargetMod(); MotionVector.X.DeltaScale = multiplier.GetDeltaMod(); MotionVector.Y.TargetScale = multiplier.GetTargetMod(); MotionVector.Y.DeltaScale = multiplier.GetDeltaMod(); } MotionVector.Adjust(elapsedInFrame); var motion = CurrentMotionPerSecond; FrameVelocity = CurrentMotionPerSecond.Scale(elapsedInFrame.TotalSeconds); ObjectToMove.Position.Translate(FrameVelocity); }
public static bool IsSimilarPositionTo(this MotionVector positionOne, MotionVector positionTwo) { var isSimilarX = IsInRange(positionOne.X, positionTwo.X, Deviation.X); var isSimilarY = IsInRange(positionOne.Y, positionTwo.Y, Deviation.Y); var isSimilarZ = IsInRange(positionOne.Z, positionTwo.Z, Deviation.Z); return(isSimilarX && isSimilarY && isSimilarZ); }
private void DeviceMotionOnSensorValueChanged(object sender, SensorValueChangedEventArgs e) { if (e.SensorType == MotionSensorType.Accelerometer) { Position = (MotionVector)e.Value; } NotifySubscribers(); }
public bool NoMoveInStartNeighbors(MotionVector confusedVector) { var sourceRoom = GetSourceRoom(confusedVector); var endRoom = this[confusedVector.EndPoint]; var startNeighbors = _neighbors[sourceRoom].ToList().AddChained(sourceRoom).RemoveChained(endRoom); return(startNeighbors.All(n => n.LastMotion.Time.GetValueOrDefault() <= confusedVector.StartTime)); }
static MotionVectorExtensions() { Deviation = new MotionVector { X = 1, Y = 1, Z = 1 }; }
void AccelSensorValueChanged(object sender, SensorValueChangedEventArgs e) { if (e.SensorType == MotionSensorType.Accelerometer) { deviceMotion = FixAccelerometerRelative((MotionVector)e.Value); #if DEBUG Debug.WriteLine("X: {0}, Y: {1}, Z{2}", deviceMotion.X, deviceMotion.Y, deviceMotion.Z); #endif } }
/// <summary> /// Get confusion point from all neighbors /// </summary> /// <param name="vector"></param> /// <returns></returns> public IList <MotionPoint> GetConfusingPoints(MotionVector vector) { var targetRoom = GetTargetRoom(vector); return(_neighbors[targetRoom].ToList() .AddChained(targetRoom) .Where(room => room.Uid != vector.StartPoint) .Select(room => room.GetConfusion(vector.EndTime)) .Where(y => y != MotionPoint.Empty) .ToList()); }
void limitsTest(MotionVector motionVector) { maxX = Max(motionVector.X, maxX); maxY = Max(motionVector.Z, maxZ); maxZ = Max(motionVector.Z, maxZ); minX = Min(motionVector.X, minX); minY = Min(motionVector.Z, minY); minZ = Min(motionVector.Z, minZ); Console.WriteLine("Max: {0}, {1}, {2}", maxX, maxY, maxZ); Console.WriteLine("Min: {0}, {1}, {2}", minX, minY, minZ); }
//============================================= //Reference C2: Externally sourced algorithms //Purpose: takes the accelerometer readings and checks to see if device was shaken //Date: 11/10/2018 //Source: W3 school //Author: unknown //URL: https://www.w3.org/TR/accelerometer/ //Adaption Required: Lowered the reading amounts (sensitivity) and changed the code to return a bool // depending on if the device was shaken or not. //============================================= // Check to see if the device was shaken private Boolean WasTheDeviceShaken(MotionVector value) { if (value.X > 15 || value.Y > 15 || value.Z > 15) { return(true); } else { return(false); } }
public Trajectory Transform(Trajectory trj) { List <MotionVector> mvs = new List <MotionVector>(); for (int i = 0; i < trj.Count; ++i) { MotionVector mv = trj[i]; mv.point = Transform(trj[i].point); mvs.Add(mv); } return(new Trajectory(mvs)); }
private double getDev(MotionVector start, MotionVector end, MotionVector middle) { Debug.Assert(end.t > start.t && middle.t > start.t && middle.t < end.t); GeoPoint pStart = start.point, pEnd = end.point; double lat, lng; lat = (pEnd.Lat - pStart.Lat) / (end.t - start.t) * (middle.t - start.t); lng = (pEnd.Lng - pStart.Lng) / (end.t - start.t) * (middle.t - start.t); double dev = GeoPoint.GetDistance(new GeoPoint(lat, lng), middle.point); return(dev); }
public IEnumerator flowMesh(List <GameObject> triangles) { GetComponent <MeshRenderer> ().enabled = false; //yield return new WaitForSeconds (2f); MotionVector[] instructions = new MotionVector[triangles.Count]; for (int n = 0; n < triangles.Count; n++) { //instructions [n].translation = new Vector3 (Random.Range(-1f, 1f), Random.Range(-1f, 1f), Random.Range(-1f, 1f)).normalized; instructions [n].rotation = new Vector3(Random.Range(-1f, 1f), Random.Range(-1f, 1f), Random.Range(-1f, 1f)).normalized; instructions [n].translation = instructions [n].rotation * scale; } Vector3 rot = new Vector3(Random.Range(-1f, 1f), Random.Range(-1f, 1f), Random.Range(-1f, 1f)).normalized; for (int i = 0; i < 90; i++) { transform.Rotate(rot * 4); int c = 0; foreach (GameObject tri in triangles) { tri.transform.Rotate(instructions [c].rotation * 4); if (i < 45) { tri.transform.Translate(instructions[c].translation); } else { tri.transform.Translate(instructions[c].translation * -1f); } c++; } yield return(null); } GetComponent <MeshRenderer> ().enabled = true; if (GetComponent <Collider> ()) { GetComponent <Collider> ().enabled = true; } foreach (GameObject tri in triangles) { Destroy(tri); } transform.rotation = initial; yield return(new WaitForSeconds(.05f)); transform.rotation = initial; }
/// <summary> /// Create fluid simulation. /// </summary> /// <param name="renderer">Renderer to use for drawing.</param> /// <param name="resolution">Resolution of renderering, from 0.0 to 1.0. The higher the resolution, the nice the simulation looks.</param> /// <param name="viscosity">Viscosity of the fluid.</param> /// <param name="diffusionRate">Diffusion rate of the fluid.</param> /// <param name="deltaTime">How fast to run simulation (milliseconds between simulation steps).</param> public FluidSimulation(IFluidRenderer renderer, float resolution, float viscosityConstant, float diffusionRateConstant, float gravityConstant, float terminalVelocityConstant, float deltaTime) { this.renderer = renderer; this.resolution = resolution; VISCOSITY_CONSTANT = viscosityConstant; DIFFUSION_RATE_CONSTANT = diffusionRateConstant; GRAVITY_CONSTANT = gravityConstant; TERMINAL_VELOCITY_CONSTANT = terminalVelocityConstant; dt = deltaTime; deviceMotion = new MotionVector(); deviceMotion.X = 0.0d; deviceMotion.Y = 1.0d; deviceMotion.Z = 9.8d; SetupSimulation(); }
private void MarkVector(MotionVector motionVector) { // If there was not confused vector from this point we don't start another if (_rooms[motionVector.End.Uid].LastVectorEnter?.EqualsWithStartTime(motionVector) ?? false) { return; } _logger.Info(motionVector.ToString()); _rooms[motionVector.Start.Uid].MarkLeave(motionVector); _rooms[motionVector.End.Uid].MarkEnter(motionVector); }
public void MarkLeave(MotionVector vector) { DecrementNumberOfPersons(); if (AreaDescriptor.MaxPersonCapacity == 1) { SetProbability(Probability.Zero); } else { //TODO change this value SetProbability(Probability.FromValue(0.1)); } }
private async Task MarkVector(MotionVector motionVector) { // If there was not confused vector from this point we don't start another if (_rooms[motionVector.End.Uid].LastVectorEnter?.EqualsWithStartTime(motionVector) ?? false) { return; } Logger.LogInformation(motionVector.ToString()); await _rooms[motionVector.Start.Uid].MarkLeave(motionVector).ConfigureAwait(false); _rooms[motionVector.End.Uid].MarkEnter(motionVector); }
/// <summary> /// Marks enter to target room and leave from source room /// </summary> /// <param name="motionVector"></param> /// <returns></returns> private async Task MarkVector(MotionVector motionVector) { var targetRoom = _roomService.GetTargetRoom(motionVector); var sourceRoom = _roomService.GetSourceRoom(motionVector); // If there was no confused vector from this point we don't start another //if (targetRoom.HasSameLastTimeVector(motionVector)) return; Logger.LogInformation(motionVector.ToString()); await sourceRoom.MarkLeave(motionVector); targetRoom.MarkEnter(motionVector); }
public async Task MarkLeave(MotionVector vector) { DecrementNumberOfPersons(); if (_areaDescriptor.MaxPersonCapacity == 1) { await SetProbability(Probability.Zero).ConfigureAwait(false); } else { //TODO change this value await SetProbability(Probability.FromValue(0.1)).ConfigureAwait(false); } }
void LimitsTestAction(MotionVector a) { var xVal = a.X; var yVal = a.Y; var zVal = a.Z; //Max if (xVal > maxX) { maxX = xVal; Console.WriteLine("X max: " + maxX); } if (yVal > maxY) { maxY = yVal; Console.WriteLine("Y max: " + maxY); } if (zVal > maxZ) { maxZ = zVal; Console.WriteLine("Z max: " + maxZ); } //Min if (xVal > minX) { minX = xVal; Console.WriteLine("X min: " + minX); } if (yVal < minY) { minY = yVal; Console.WriteLine("Y min: " + minY); } if (zVal < minZ) { minZ = zVal; Console.WriteLine("Z min: " + minZ); } }
public void Stop(Axis axis, bool setTarget = false) { MotionVector.GetAxis(axis).Current = 0; if (axis == Axis.X) { ObjectToMove.Position.SetLeft(FrameStartPosition.Left); } else if (axis == Axis.Y) { ObjectToMove.Position.SetTop(FrameStartPosition.Top); } if (setTarget) { MotionVector.GetAxis(axis).SetTarget(0, 0); } }
private void HandleVector(MotionVector motionVector) { var confusionPoints = _rooms[motionVector.End.Uid].GetConfusingPoints(motionVector); if (confusionPoints.Count == 0) { MarkVector(motionVector); } else if (_rooms[motionVector.Start.Uid].NumberOfPersonsInArea > 0) { _logger.Info($"{motionVector} [Confused: {string.Join(" | ", confusionPoints)}]"); _confusedVectors.Add(motionVector.Confuze(confusionPoints)); } // If there is no more people in area this confusion is resolved immediately because it is physically impossible else { _logger.Info($"{motionVector} [Deleted]"); } }
/// <summary> /// Handle move between rooms represented by <seealso cref="MotionVector"/> /// </summary> /// <param name="motionVector"></param> private async Task HandleVector(MotionVector motionVector) { var confusionPoints = _roomService.GetConfusingPoints(motionVector); if (confusionPoints.Count == 0) { await MarkVector(motionVector); } else if (_roomService.GetSourceRoom(motionVector).NumberOfPersonsInArea > 0) { Logger.LogInformation($"{motionVector} [Confused: {string.Join(" | ", confusionPoints)}]"); _confusedVectors.Add(motionVector.WithConfuze(confusionPoints)); } // If there is no more people in area this confusion is resolved immediately because it is physically impossible else { Logger.LogInformation($"{motionVector} [Deleted]"); } }
public static MotionVector FixAccelerometerRelative(MotionVector deviceMotion) { MotionVector result = deviceMotion; if (Xamarin.Forms.Device.RuntimePlatform == Xamarin.Forms.Device.Android) { var rotation = CrossRotationService.Instance.GetRotation(); int[][] axisSwaps = new int[4][] { new int[4] { 1, -1, 0, 1 }, // ROTATION_0 new int[4] { -1, -1, 1, 0 }, // ROTATION_90 new int[4] { -1, 1, 0, 1 }, // ROTATION_180 new int[4] { 1, 1, 1, 0 } // ROTATION_270 }; double[] motionVals = new double[3] { deviceMotion.X, deviceMotion.Y, deviceMotion.Z }; int[] axisSwap = axisSwaps[(int)rotation]; result.X = (double)axisSwap[0] * motionVals[axisSwap[2]]; result.Y = (double)axisSwap[1] * motionVals[axisSwap[3]] * -1; // Need to flip Y. result.Z = motionVals[2]; } if (Xamarin.Forms.Device.RuntimePlatform == Xamarin.Forms.Device.iOS) { result.X *= -1; result.Y *= -1; } return(result); }
void LimitsTestFunction(MotionVector a) { var x = a.X; var y = a.Y; var z = a.Z; if (x > maxX) { maxX = x; Console.WriteLine("x Max: " + maxX); } if (y > maxY) { maxY = x; Console.WriteLine("x Max: " + maxX); } if (z > maxZ) { maxZ = x; Console.WriteLine("x Max: " + maxX); } if (x < minX) { minX = x; Console.WriteLine("x Min: " + minX); } if (y < minY) { minY = y; Console.WriteLine("y Min: " + minY); } if (z < minZ) { minZ = z; Console.WriteLine("z Min: " + minZ); } }
private void HandleVector(MotionVector motionVector) { var confusionPoints = _rooms[motionVector.End.Uid].GetConfusingPoints(motionVector); if (confusionPoints.Count == 0) { //TODO change this to Async? //https://github.com/dotnet/reactive/issues/459 //https://stackoverflow.com/questions/23006852/howto-call-back-async-function-from-rx-subscribe //https://stackoverflow.com/questions/37412129/how-to-subscribe-with-async-method-in-rx MarkVector(motionVector).GetAwaiter().GetResult(); } else if (_rooms[motionVector.Start.Uid].NumberOfPersonsInArea > 0) { Logger.LogInformation($"{motionVector} [Confused: {string.Join(" | ", confusionPoints)}]"); _confusedVectors.Add(motionVector.Confuze(confusionPoints)); } // If there is no more people in area this confusion is resolved immediately because it is physically impossible else { Logger.LogInformation($"{motionVector} [Deleted]"); } }