private static (Point centre, double radius, double angle) GetPinchValues(List <Point> locations) { if (locations.Count < 2) { throw new ArgumentException(); } double centerX = 0; double centerY = 0; foreach (var location in locations) { centerX += location.X; centerY += location.Y; } centerX = centerX / locations.Count; centerY = centerY / locations.Count; var radius = Algorithms.Distance(centerX, centerY, locations[0].X, locations[0].Y); var angle = Math.Atan2(locations[1].Y - locations[0].Y, locations[1].X - locations[0].X) * 180.0 / Math.PI; return(new Point(centerX, centerY), radius, angle); }
/// <summary> /// Converts a direction cosine matrix to yaw, pitch, roll in radians. /// </summary> /// <param name="dcm"> /// The direction cosine matrix. /// </param> /// <returns> /// The corresponding yaw, pitch, roll in radians. /// </returns> public static vec3f Dcm2YprInRads(mat3f dcm) { return(new vec3f( (float)SMath.Atan2(dcm.E01, dcm.E00), (float)SMath.Asin(-dcm.E02), (float)SMath.Atan2(dcm.E12, dcm.E22))); }
public static float Yaw(QuaternionF quat) { //Contract.Requires<ArgumentNullException>(quat != null, "quat"); return((float)SysMath.Atan2( 2.0f * (quat._w * quat._z + quat._x * quat._y), 1.0f - 2.0f * (quat._y * quat._y + quat._z * quat._z))); }
public static float DefineAngle(Vec2 start, Vec2 end) { //позиция мыши float angle = (float)(Math.Atan2(end.Y - start.Y, end.X - start.X) / Math.PI * 180); angle = (angle < 0) ? angle + 360 : angle; return(angle); }
public static double GetAngle(Point center, Point endPoint) { var result = M.Atan2(endPoint.Y - center.Y, endPoint.X - center.X); if (result < 0) { result += 2 * PI; } return(result); }
private void Apply3DImpl(AudioListener listener, AudioEmitter emitter) { // Since android has no function available to perform sound 3D localization by default, here we try to mimic the behaviour of XAudio2 // After an analysis of the XAudio2 left/right stereo balance with respect to 3D world position, // it could be found the volume repartition is symmetric to the Up/Down and Front/Back planes. // Moreover the left/right repartition seems to follow a third degree polynomial function: // Volume_left(a) = 2(c-1)*a^3 - 3(c-1)*a^2 + c*a , where c is a constant close to c = 1.45f and a is the angle normalized bwt [0,1] // Volume_right(a) = 1-Volume_left(a) // As for signal attenuation wrt distance the model follows a simple inverse square law function as explained in XAudio2 documentation // ( http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.x3daudio.x3daudio_emitter(v=vs.85).aspx ) // Volume(d) = 1 , if d <= ScaleDistance where d is the distance to the listener // Volume(d) = ScaleDistance / d , if d >= ScaleDistance where d is the distance to the listener // 1. Attenuation due to distance. var vecListEmit = emitter.Position - listener.Position; var distListEmit = vecListEmit.Length(); var attenuationFactor = distListEmit <= emitter.DistanceScale ? 1f : emitter.DistanceScale / distListEmit; // 2. Left/Right balance. var repartRight = 0.5f; var worldToList = Matrix.Identity; var rightVec = Vector3.Cross(listener.Forward, listener.Up); worldToList.Column1 = new Vector4(rightVec, 0); worldToList.Column2 = new Vector4(listener.Forward, 0); worldToList.Column3 = new Vector4(listener.Up, 0); var vecListEmitListBase = Vector3.TransformNormal(vecListEmit, worldToList); var vecListEmitListBase2 = (Vector2)vecListEmitListBase; if (vecListEmitListBase2.Length() > 0) { const float c = 1.45f; var absAlpha = Math.Abs(Math.Atan2(vecListEmitListBase2.Y, vecListEmitListBase2.X)); var normAlpha = (float)(absAlpha / (Math.PI / 2)); if (absAlpha > Math.PI / 2) { normAlpha = 2 - normAlpha; } repartRight = 0.5f * (2 * (c - 1) * normAlpha * normAlpha * normAlpha - 3 * (c - 1) * normAlpha * normAlpha * normAlpha + c * normAlpha); if (absAlpha > Math.PI / 2) { repartRight = 1 - repartRight; } } // Set the volumes. localizationChannelVolumes = new[] { attenuationFactor *(1f - repartRight), attenuationFactor *repartRight }; UpdateStereoVolumes(); // 3. Calculation of the Doppler effect ComputeDopplerFactor(listener, emitter); UpdatePitch(); }
public double Angle(TVec a, TVec b) { //return (this.Angle(b) - this.Angle(a)); // http://stackoverflow.com/questions/2150050/finding-signed-angle-between-vectors double ax = a.X.ToDouble(); double ay = a.Y.ToDouble(); double bx = b.X.ToDouble(); double by = b.Y.ToDouble(); return(SysMath.Atan2(ax * by - ay * bx, ax * bx + ay * by)); }
public bool IsClockWise(Vector2 pointA, Vector2 pointB, Vector2 pointC) { var v1x = pointB.X - pointC.X; var v1y = pointB.Y - pointC.Y; var v2x = pointA.X - pointC.X; var v2y = pointA.Y - pointC.Y; var angle = Math.Atan2(v1x, v1y) - Math.Atan2(v2x, v2y); return(angle >= Math.PI || angle < 0); }
public static double GetAngle(Vector2D vector, bool asRadian = true) { var result = SysMath.Atan2(vector.Y, vector.X); if (!asRadian) { return(AsAngle(result)); } return(result); }
private static double Angle(MotionEvent me) { if (me.PointerCount < 2) { throw new ArgumentException(); } var x = me.GetX(0) - me.GetX(1); var y = me.GetY(0) - me.GetY(1); var rotation = Math.Atan2(me.GetY(1) - me.GetY(0), me.GetX(1) - me.GetX(0)) * 180.0 / Math.PI; return(rotation); }
public static double GetAngle(Vector2D p1, Vector2D p2, bool asRadian = true) { double xDiff = p2.X - p1.X; double yDiff = p2.Y - p1.Y; if (asRadian) { return(SysMath.Atan2(yDiff, xDiff)); } else { return(AsAngle(SysMath.Atan2(yDiff, xDiff))); } }
public static double GetAngle(double x1, double x2, double y1, double y2, bool asRadian = true) { double xDiff = x2 - x1; double yDiff = y2 - y1; if (asRadian) { return(SysMath.Atan2(yDiff, xDiff)); } else { return(AsAngle(SysMath.Atan2(yDiff, xDiff))); } }
/// <summary> /// Return the angle between the 2 2D (X, Y) vectors in radian from -PI to +PI. /// </summary> public static float Angle2D(Vector3 v1, Vector3 v2) { double angle = CSharpMath.Atan2(v2.Y, v2.X) - CSharpMath.Atan2(v1.Y, v1.X); if (angle > CSharpMath.PI) { angle -= (CSharpMath.PI * 2.0); } else if (angle < (0.0 - CSharpMath.PI)) { angle += (CSharpMath.PI * 2.0); } return((float)angle); }
public void Atan2誤差1パーセント以下の精度で計算できる() { void assertYX(T y, T x) { var t1 = Table.Atan2(y, x); var t2 = M.Atan2(y, x); Assert.True(M.Abs(t1 - t2) < 2e-3); } void assert(T theta) { var(y, x) = (M.Cos(theta), M.Sin(theta)); assertYX(y, x); } var r = new Random(); for (int i = 0; i < 1000; i++) { var theta = r.NextDouble() * 1000 - 500; assert(theta); } for (int i = 0; i < 1000; i++) { var y = r.NextDouble() * 1000 - 500; var x = r.NextDouble() * 1000 - 500; assertYX(y, x); } foreach (var theta in _cornerCase) { assert(theta); } for (int x = -1; x <= 1; x++) { for (int y = -1; y <= 1; y++) { assertYX(x, y); } } }
public bool Intersect(Planet planet) { var distance = (float)Math.Sqrt(Math.Pow(planet.Transform.X - Transform.X, 2) + Math.Pow(planet.Transform.Y - Transform.Y, 2)); var totalRadius = Radius + planet.Radius; if (distance <= totalRadius && planet.IsCheck == false) { var angle = (float)Math.Atan2(Transform.Y - planet.Transform.Y, Transform.X - planet.Transform.X); angle += (float)Math.PI / 2 - planet.Transform.Angle; // planet.AngularVelocity = 0.04f; planet.CorrectAngle = -angle; // planet.Angle = angle; planet.IsCheck = true; SetPlanet(planet); ((GameScreen)_engine.Screens.CurrentScreen).LayoutTop.IncrementBalls(); IncrementBalls?.Invoke(null, null); return(true); } return(false); }
/// <summary> /// Busca el desarrollo de la clotoide cuya tangente es <c>v</c>: DClotho x v = 0. /// Por simetria, existen 2 soluciones, el desarrollo positivo y el negativo. /// </summary> public static double FindTangent(bool invertY, double a, Vector2d v) { int ysign = (invertY ? -1 : 1); return(SysMath.Sqrt(2 * a * a * SysMath.Atan2(ysign * v.Y, v.X))); }
public static Half Atan2(Half x, Half y) => (Half)M.Atan2(y, x);
public static double Atan2(double value1, double value2) { return(CSMath.Atan2(value1, value2) * kRadiansToDegrees); }
public static Angle Atan2(Real y, Real x) { return(FromRadians(Math.Atan2(y, x))); }
/// <summary> /// Finds the inverse tangent of quotient of two numbers. Returns the angle /// whose tangent is the ratio: numerator/denominator. /// </summary> /// <param name="numerator">The numerator of the tangent of the angle.</param> /// <param name="denominator">The denominator of the tangent of the angle.</param> /// <returns name="angle">The angle whose tangent is numerator/denominator.</returns> /// <search>atangent,arctangent</search> public static double Atan2(double numerator, double denominator) { return(CSMath.Atan2(numerator, denominator) * kRadiansToDegrees); }
/// <summary> /// Calculates an angle out of given coordinates. /// </summary> /// <param name="x">The x.</param> /// <param name="y">The y.</param> public static float ToAngle(float x, float y) { return((float)Math.Atan2(y, x) + MathHelper.Pi); }
public float GetAngle() { return((float)Math.Atan2(Y, X)); }
public static float Yaw(QuaternionF quat) { return((float)SysMath.Atan2( 2.0f * (quat._w * quat._z + quat._x * quat._y), 1.0f - 2.0f * (quat._y * quat._y + quat._z * quat._z))); }
public static float Roll(QuaternionF quat) { return((float)SysMath.Atan2( 2.0f * (quat._w * quat._x + quat._y * quat._z), 1.0f - 2.0f * (quat._x * quat._x + quat._y * quat._y))); }
/// <summary> /// Sets the Angle by using a direction vector. /// </summary> /// <param name="direction">The direction vector.</param> public void SetDirectionVector(Vector direction) { ClockwiseRadians = NMath.Atan2(direction.Ycomponent, direction.Xcomponent); }
/*public T Angle(TVec v) * { * return math.Atan2(v.Y, v.X); * }*/ public double Angle(TVec v) { return(SysMath.Atan2(v.Y.ToDouble(), v.X.ToDouble())); }
public static double Atan2(double y, double x) => Math.Atan2(y, x);
public float GetAngle2(Branch branch) { return((float)Math.Atan2(Y - branch.Y, X - branch.X)); }
public static float Atan2(float x, float y) { return((float)XMath.Atan2(x, y)); }
public static double Atan2(double y, double x) { return(Math.Atan2(y, x)); }