public void TestCrossProduct()
{
double angle = Math.PI / 4.0;
double cos = Math.Cos(angle / 2.0);
double sin = Math.Sin(angle / 2.0);
double a = cos * cos - sin * sin / 3.0;
double b = 2.0 * (sin * sin + sin * cos * Math.Sqrt(3.0)) / 3.0;
double c = 2.0 * (sin * sin - sin * cos * Math.Sqrt(3.0)) / 3.0;
// The three vectors here are the orthonormal set obtained by rotating
// the x-axis, y-axis, and z-axis through an angle of 45 degrees about
// the (1,1,1) vector.
UnitCartesian first = new UnitCartesian(a, b, c);
UnitCartesian second = new UnitCartesian(c, a, b);
UnitCartesian third = new UnitCartesian(b, c, a);
Cartesian result = first.Cross(second);
Assert.AreEqual(third.X, result.X, Constants.Epsilon14);
Assert.AreEqual(third.Y, result.Y, Constants.Epsilon14);
Assert.AreEqual(third.Z, result.Z, Constants.Epsilon14);
Cartesian Cartesian3 = new Cartesian(c, a, b);
result = first.Cross(Cartesian3);
Assert.AreEqual(third.X, result.X, Constants.Epsilon14);
Assert.AreEqual(third.Y, result.Y, Constants.Epsilon14);
Assert.AreEqual(third.Z, result.Z, Constants.Epsilon14);
}
/// <summary>
/// 惯性系到飞行器LVLH坐标系的转换矩阵
/// </summary>
/// <param name="r">惯性系下的位置矢量</param>
/// <param name="V">惯性系下的速度矢量</param>
/// <returns></returns>
public static Matrix3By3 Initial2LVLH(Cartesian r, Cartesian v)
{
UnitCartesian h = new UnitCartesian(r.Cross(v));
Cartesian uz = new Cartesian(0, 0, 1);
//升交点赤径所在单位向量坐标
UnitCartesian uraan = new UnitCartesian(uz.Cross(h));
//轨道倾角
double inc = Math.Acos(h.Z);
//升交点赤径
double raan = Math.Atan2(uraan.Y, uraan.X);
//w+f
double u = Math.Acos(r.Dot(uraan) / r.Magnitude);
if (r.Z < 0)
{
u = -u;
}
ElementaryRotation rot1 = new ElementaryRotation(AxisIndicator.Third, raan);
ElementaryRotation rot2 = new ElementaryRotation(AxisIndicator.First, inc);
ElementaryRotation rot3 = new ElementaryRotation(AxisIndicator.Third, u);
return(rot3.Multiply(rot2).Multiply(rot1));
}
public void TestHoldValue()
{
UnitCartesian test = new UnitCartesian(2.0, 3.0, 6.0);
Assert.AreEqual(2.0 / 7.0, test.X);
Assert.AreEqual(3.0 / 7.0, test.Y);
Assert.AreEqual(6.0 / 7.0, test.Z);
}
public void TestFromInfinity()
{
Assert.Throws <NotFiniteNumberException>(() =>
{
var unused = new UnitCartesian(double.PositiveInfinity, 0.0, 0.0);
});
}
/// <summary>
/// Writes time-tagged <see cref="UnitCartesian"/> values as an array in [Time, X, Y, Z] order.
/// Times are epoch seconds since an epoch that is determined from the first date to be written.
/// The epoch property is written as well.
/// </summary>
/// <param name="output">The stream to which to write the array.</param>
/// <param name="propertyName">The name of the property to write.</param>
/// <param name="dates">The dates at which the value is specified.</param>
/// <param name="values">The corresponding value for each date.</param>
/// <param name="startIndex">The index of the first element to use in the <paramref name="values"/> collection.</param>
/// <param name="length">The number of elements to use from the <paramref name="values"/> collection.</param>
public static void WriteUnitCartesian3(CesiumOutputStream output, string propertyName, IList <JulianDate> dates, IList <UnitCartesian> values, int startIndex, int length)
{
if (dates.Count != values.Count)
{
throw new ArgumentException(CesiumLocalization.MismatchedNumberOfDatesAndValues, "values");
}
JulianDate epoch = GetAndWriteEpoch(output, dates, startIndex, length);
output.WritePropertyName(propertyName);
output.WriteStartSequence();
int last = startIndex + length;
for (int i = startIndex; i < last; ++i)
{
output.WriteValue(epoch.SecondsDifference(dates[i]));
UnitCartesian value = values[i];
output.WriteValue(value.X);
output.WriteValue(value.Y);
output.WriteValue(value.Z);
output.WriteLineBreak();
}
output.WriteEndSequence();
}
public void TestFromCartesian()
{
UnitCartesian test = new UnitCartesian(new Cartesian(2.0, 3.0, 6.0));
Assert.AreEqual(2.0 / 7.0, test.X, Constants.Epsilon15);
Assert.AreEqual(3.0 / 7.0, test.Y, Constants.Epsilon15);
Assert.AreEqual(6.0 / 7.0, test.Z, Constants.Epsilon15);
}
public void TestFromZero()
{
Assert.Throws <DivideByZeroException>(() =>
{
var unused = new UnitCartesian(Cartesian.Zero);
});
}
public void TestSubtract()
{
UnitCartesian original = UnitCartesian.UnitX;
UnitCartesian toAdd1 = UnitCartesian.UnitY;
Cartesian result = original - toAdd1;
Assert.AreEqual(1.0, result.X);
Assert.AreEqual(-1.0, result.Y);
Assert.AreEqual(0.0, result.Z);
Cartesian toAdd2 = new Cartesian(0.0, 1.0, 1.0);
result = original - toAdd2;
Assert.AreEqual(1.0, result.X);
Assert.AreEqual(-1.0, result.Y);
Assert.AreEqual(-1.0, result.Z);
Cartesian original2 = new Cartesian(0.0, 1.0, 1.0);
UnitCartesian toAdd3 = UnitCartesian.UnitX;
result = original2 - toAdd3;
Assert.AreEqual(-1.0, result.X);
Assert.AreEqual(1.0, result.Y);
Assert.AreEqual(1.0, result.Z);
}
public void TestCrossProduct()
{
double angle = Math.PI / 4.0;
double cos = Math.Cos(angle / 2.0);
double sin = Math.Sin(angle / 2.0);
double a = cos * cos - sin * sin / 3.0;
double b = 2.0 * (sin * sin + sin * cos * Math.Sqrt(3.0)) / 3.0;
double c = 2.0 * (sin * sin - sin * cos * Math.Sqrt(3.0)) / 3.0;
// The three vectors here are the orthonormal set obtained by rotating
// the x-axis, y-axis, and z-axis through an angle of 45 degrees about
// the (1,1,1) vector.
UnitCartesian first = new UnitCartesian(a, b, c);
UnitCartesian second = new UnitCartesian(c, a, b);
UnitCartesian third = new UnitCartesian(b, c, a);
Cartesian result = first.Cross(second);
Assert.AreEqual(third.X, result.X, Constants.Epsilon14);
Assert.AreEqual(third.Y, result.Y, Constants.Epsilon14);
Assert.AreEqual(third.Z, result.Z, Constants.Epsilon14);
Cartesian Cartesian3 = new Cartesian(c, a, b);
result = first.Cross(Cartesian3);
Assert.AreEqual(third.X, result.X, Constants.Epsilon14);
Assert.AreEqual(third.Y, result.Y, Constants.Epsilon14);
Assert.AreEqual(third.Z, result.Z, Constants.Epsilon14);
}
public void TestEqualityWithWrongType()
{
UnitCartesian first = new UnitCartesian(1.0, 2.0, 3.0);
Cartographic second = new Cartographic(1.0, 2.0, 3.0);
Assert.IsFalse(first.Equals(second));
}
public void TestEqualsEpsilonExact()
{
UnitCartesian first = new UnitCartesian(0.1, 0.1, 0.1);
UnitCartesian second = new UnitCartesian(0.1, 0.1, 0.1);
Assert.IsTrue(second.EqualsEpsilon(first, 0));
}
public void TestNegation()
{
UnitCartesian u = -new UnitCartesian(2.0, 3.0, 6.0);
Assert.AreEqual(-2.0 / 7.0, u.X);
Assert.AreEqual(-3.0 / 7.0, u.Y);
Assert.AreEqual(-6.0 / 7.0, u.Z);
}
public void TestFromCartesian()
{
UnitCartesian test = new UnitCartesian(new Cartesian(2.0, 3.0, 6.0));
Assert.AreEqual(2.0 / 7.0, test.X, Constants.Epsilon15);
Assert.AreEqual(3.0 / 7.0, test.Y, Constants.Epsilon15);
Assert.AreEqual(6.0 / 7.0, test.Z, Constants.Epsilon15);
}
public void TestConversionFromUnitCartesian()
{
UnitCartesian unit = new UnitCartesian(1.0, 1.0, 1.0);
Cartesian test = unit;
Assert.AreEqual(unit.X, test.X);
Assert.AreEqual(unit.Y, test.Y);
Assert.AreEqual(unit.Z, test.Z);
}
/// <summary>
/// Writes a <see cref="UnitCartesian"/> value as an array in X, Y, Z order.
/// </summary>
/// <param name="output">The stream to which to write the value.</param>
/// <param name="value">The value to write.</param>
public static void WriteUnitCartesian3(CesiumOutputStream output, UnitCartesian value)
{
output.WriteStartSequence();
output.WriteValue(value.X);
output.WriteValue(value.Y);
output.WriteValue(value.Z);
output.WriteEndSequence();
}
public void TestEqualityWithWrongType()
{
UnitCartesian first = new UnitCartesian(1.0, 2.0, 3.0);
Cartographic second = new Cartographic(1.0, 2.0, 3.0);
// ReSharper disable once SuspiciousTypeConversion.Global
Assert.IsFalse(first.Equals(second));
}
public void TestHoldValue()
{
UnitCartesian test = new UnitCartesian(2.0, 3.0, 6.0);
Assert.AreEqual(2.0 / 7.0, test.X);
Assert.AreEqual(3.0 / 7.0, test.Y);
Assert.AreEqual(6.0 / 7.0, test.Z);
}
public void TestInvert()
{
UnitCartesian Cartesian3 = new UnitCartesian(2.0, 3.0, 6.0);
UnitCartesian inverted = Cartesian3.Invert();
Assert.AreEqual(-2.0 / 7.0, inverted.X);
Assert.AreEqual(-3.0 / 7.0, inverted.Y);
Assert.AreEqual(-6.0 / 7.0, inverted.Z);
}
public void TestGetHashCode()
{
UnitCartesian object1 = new UnitCartesian(1.0, 2.0, 3.0);
UnitCartesian object2 = new UnitCartesian(1.0, 2.0, 3.0);
UnitCartesian object3 = new UnitCartesian(1.0, 2.0, 3.1);
Assert.AreEqual(object1.GetHashCode(), object2.GetHashCode());
Assert.AreNotEqual(object1.GetHashCode(), object3.GetHashCode());
}
public void TestNormalize()
{
Cartesian test = new Cartesian(2.0, 3.0, 6.0);
UnitCartesian unit = test.Normalize();
Assert.AreEqual(2.0 / 7.0, unit.X);
Assert.AreEqual(3.0 / 7.0, unit.Y);
Assert.AreEqual(6.0 / 7.0, unit.Z);
}
public void TestConversionFromUnitCartesian()
{
UnitCartesian unit = new UnitCartesian(1.0, 1.0, 1.0);
Cartesian test = unit;
Assert.AreEqual(unit.X, test.X);
Assert.AreEqual(unit.Y, test.Y);
Assert.AreEqual(unit.Z, test.Z);
}
public void TestInitializeAndReturnMagnitude()
{
double magnitude;
UnitCartesian test = new UnitCartesian(2.0, 3.0, 6.0, out magnitude);
Assert.AreEqual(2.0 / 7.0, test.X, Constants.Epsilon15);
Assert.AreEqual(3.0 / 7.0, test.Y, Constants.Epsilon15);
Assert.AreEqual(6.0 / 7.0, test.Z, Constants.Epsilon15);
Assert.AreEqual(7.0, magnitude, Constants.Epsilon15);
}
public void TestAngleBetween()
{
double fortyFiveDegrees = Math.PI / 4.0;
UnitCartesian first = new UnitCartesian(1.0, 1.0, 0.0);
UnitCartesian second = new UnitCartesian(1.0, 1.0, Math.Sqrt(2.0));
Assert.AreEqual(fortyFiveDegrees, second.AngleBetween(first), Constants.Epsilon15);
}
public void TestInitializeAndReturnMagnitude()
{
double magnitude;
UnitCartesian test = new UnitCartesian(2.0, 3.0, 6.0, out magnitude);
Assert.AreEqual(2.0 / 7.0, test.X, Constants.Epsilon15);
Assert.AreEqual(3.0 / 7.0, test.Y, Constants.Epsilon15);
Assert.AreEqual(6.0 / 7.0, test.Z, Constants.Epsilon15);
Assert.AreEqual(7.0, magnitude, Constants.Epsilon15);
}
public void TestToString()
{
UnitCartesian test1 = new UnitCartesian(1.0, 0.0, 0.0);
UnitCartesian test2 = new UnitCartesian(0.0, 1.0, 0.0);
UnitCartesian test3 = new UnitCartesian(0.0, 0.0, 1.0);
Assert.AreEqual("1, 0, 0", test1.ToString());
Assert.AreEqual("0, 1, 0", test2.ToString());
Assert.AreEqual("0, 0, 1", test3.ToString());
}
public void TestFromArray()
{
double[] values = { 2.0, 3.0, 6.0 };
UnitCartesian test = new UnitCartesian(values);
Assert.AreEqual(values.Length, test.Length);
Assert.AreEqual(test.X, test[0]);
Assert.AreEqual(test.Y, test[1]);
Assert.AreEqual(test.Z, test[2]);
}
public void TestMostParallelAxis()
{
UnitCartesian Cartesian3 = new UnitCartesian(1.0, 2.0, 3.0);
Assert.AreEqual(UnitCartesian.UnitZ, Cartesian3.MostParallelAxis);
Cartesian3 = new UnitCartesian(2.0, 3.0, 1.0);
Assert.AreEqual(UnitCartesian.UnitY, Cartesian3.MostParallelAxis);
Cartesian3 = new UnitCartesian(3.0, 1.0, 2.0);
Assert.AreEqual(UnitCartesian.UnitX, Cartesian3.MostParallelAxis);
}
public void MostOrthogonalAxis()
{
Cartesian v = new UnitCartesian(1.0, 2.0, 3.0);
Assert.AreEqual(UnitCartesian.UnitX, v.MostOrthogonalAxis);
v = new UnitCartesian(2.0, 3.0, 1.0);
Assert.AreEqual(UnitCartesian.UnitZ, v.MostOrthogonalAxis);
v = new UnitCartesian(3.0, 1.0, 2.0);
Assert.AreEqual(UnitCartesian.UnitY, v.MostOrthogonalAxis);
}
public void TestFromArray()
{
double[] values = { 2.0, 3.0, 6.0 };
UnitCartesian test = new UnitCartesian(values);
Assert.AreEqual(values.Length, test.Length);
Assert.AreEqual(test.X, test[0]);
Assert.AreEqual(test.Y, test[1]);
Assert.AreEqual(test.Z, test[2]);
}
public void TestFromClockAndCone()
{
double fortyFiveDegrees = Math.PI / 4.0;
double thirtyDegrees = Math.PI / 6.0;
UnitCartesian test = new UnitCartesian(thirtyDegrees, fortyFiveDegrees);
Assert.AreEqual(Math.Sqrt(3.0) / Math.Sqrt(8.0), test.X, Constants.Epsilon15);
Assert.AreEqual(1.0 / Math.Sqrt(8.0), test.Y, Constants.Epsilon15);
Assert.AreEqual(1.0 / Math.Sqrt(2.0), test.Z, Constants.Epsilon15);
}
public void TestEqualsEpsilon()
{
UnitCartesian first = new UnitCartesian(1.0, 1.0, 1.0);
UnitCartesian second = new UnitCartesian(0.99, 1.0, 1.01);
Assert.IsTrue(second.EqualsEpsilon(first, 1e-1));
Assert.IsTrue(second.EqualsEpsilon(first, 1e-2));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-3));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-4));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-5));
}
public void TestDotProduct()
{
UnitCartesian first = new UnitCartesian(1.0, 3.0, -2.0);
UnitCartesian second = new UnitCartesian(4.0, -2.0, -1.0);
Assert.AreEqual(0, first.Dot(second), Constants.Epsilon15);
Assert.AreEqual(0, second.Dot(first), Constants.Epsilon15);
Cartesian result = new Cartesian(4.0, -2.0, -1.0);
Assert.AreEqual(0, first.Dot(result));
}
public void MostOrthogonalAxis()
{
Cartesian v = new UnitCartesian(1.0, 2.0, 3.0);
Assert.AreEqual(UnitCartesian.UnitX, v.MostOrthogonalAxis);
v = new UnitCartesian(2.0, 3.0, 1.0);
Assert.AreEqual(UnitCartesian.UnitZ, v.MostOrthogonalAxis);
v = new UnitCartesian(3.0, 1.0, 2.0);
Assert.AreEqual(UnitCartesian.UnitY, v.MostOrthogonalAxis);
}
public void TestDivide()
{
UnitCartesian original = new UnitCartesian(2.0, 3.0, 6.0);
Cartesian result = original / 2.0;
Assert.AreEqual(2.0 / 14.0, result.X);
Assert.AreEqual(3.0 / 14.0, result.Y);
Assert.AreEqual(6.0 / 14.0, result.Z);
result = original.Divide(2.0);
Assert.AreEqual(2.0 / 14.0, result.X);
Assert.AreEqual(3.0 / 14.0, result.Y);
Assert.AreEqual(6.0 / 14.0, result.Z);
}
public void TestDivide()
{
UnitCartesian original = new UnitCartesian(2.0, 3.0, 6.0);
Cartesian result = original / 2.0;
Assert.AreEqual(2.0 / 14.0, result.X);
Assert.AreEqual(3.0 / 14.0, result.Y);
Assert.AreEqual(6.0 / 14.0, result.Z);
result = original.Divide(2.0);
Assert.AreEqual(2.0 / 14.0, result.X);
Assert.AreEqual(3.0 / 14.0, result.Y);
Assert.AreEqual(6.0 / 14.0, result.Z);
}
static void Main(string[] args)
{
// 球坐标转为笛卡尔坐标
var spherical0 = new Spherical(Math.PI / 4, Math.PI / 8, 100.0);
var cartesian0 = new Cartesian(spherical0);
Console.WriteLine("球坐标：{0}；笛卡尔坐标：{1}", spherical0, cartesian0);
// 笛卡尔坐标归一化
UnitCartesian unitCartesian1 = cartesian0.Normalize();
Console.WriteLine("单位矢量笛卡尔坐标：{0}", unitCartesian1);
// 地图坐标转为笛卡尔坐标
var cartographic2 = new Cartographic(Trig.DegreesToRadians(120), Trig.DegreesToRadians(30), 100);
EarthCentralBody earth = CentralBodiesFacet.GetFromContext().Earth;
Cartesian cartesian2 = earth.Shape.CartographicToCartesian(cartographic2);
Console.WriteLine("地图坐标：{0}；笛卡尔坐标：{1}", cartographic2, cartesian2);
// 笛卡尔坐标转为地图坐标
Cartographic cartographic3 = earth.Shape.CartesianToCartographic(cartesian2);
Console.WriteLine("笛卡尔坐标：{0}；地图坐标：{1}", cartesian2, cartographic3);
// 新坐标系绕原坐标系z轴旋转90度，原向量(1,0,0)
var vector4 = new Cartesian(1, 0, 0);
var rotation4 = new ElementaryRotation(AxisIndicator.Third, Trig.DegreesToRadians(90));
Cartesian newVector4 = new Matrix3By3(rotation4).Multiply(vector4);
Console.WriteLine("旋转前：{0}；旋转后：{1}", vector4, newVector4);
// 欧拉旋转
var vector5 = new Cartesian(1, 0, 0);
double angle = Trig.DegreesToRadians(90);
var euler = new EulerSequence(angle, angle, angle, EulerSequenceIndicator.Euler321);
Cartesian newVector5 = new Matrix3By3(euler).Multiply(vector5);
Console.WriteLine("旋转前：{0}；旋转后：{1}", vector5, newVector5);
// 偏航俯仰翻滚旋转
var vector6 = new Cartesian(1, 0, 0);
double angle6 = Trig.DegreesToRadians(90);
var ypr = new YawPitchRoll(angle, angle, angle, YawPitchRollIndicator.YPR);
Cartesian newVector6 = new Matrix3By3(ypr).Multiply(vector6);
Console.WriteLine("旋转前：{0}；旋转后：{1}", vector6, newVector6);
Console.Read();
}
public void TestMultiply()
{
UnitCartesian original = new UnitCartesian(2.0, 3.0, 6.0);
Cartesian multiplied = original * 7.0;
Assert.AreEqual(2.0, multiplied.X);
Assert.AreEqual(3.0, multiplied.Y);
Assert.AreEqual(6.0, multiplied.Z);
multiplied = 7.0 * original;
Assert.AreEqual(2.0, multiplied.X);
Assert.AreEqual(3.0, multiplied.Y);
Assert.AreEqual(6.0, multiplied.Z);
}
/// <summary>
/// 单圈Lambert方程求解(转移角度:[0,2*pi))
/// <para>Gm,r,v,tof单位要一致</para>
/// <para>根据初始位置速度r1,v1确定转移轨道的方向,进而确定转移轨道的角度theta!</para>
/// <para>程序内部调用采用R.H.Gooding 方法的子程序VLamb</para>
/// </summary>
/// <param name="Gm">引力常数</param>
/// <param name="r1">初始位置矢量</param>
/// <param name="v1">初始速度矢量</param>
/// <param name="r2">末态位置矢量</param>
/// <param name="v2">末态速度矢量</param>
/// <param name="tof">转移时间</param>
/// <param name="dv1">初始速度增量</param>
/// <param name="dv2">末态速度增量</param>
public static void Lambert_RhGooding(double Gm, Cartesian r1, Cartesian v1, Cartesian r2, Cartesian v2, double tof, out Cartesian dv1, out Cartesian dv2)
{
double cos_theta = r1.Dot(r2) / r1.Magnitude / r2.Magnitude;
// 由初始位置速度矢量计算角动量方向,并计算转移轨道的的法向方向
UnitCartesian h1 = r1.Cross(v1).Normalize();
Cartesian h12 = r1.Cross(r2);
// 若始末位置在同一直线上，则令转移轨道的角动量方向同初始角动量方向相同
if (h12.Magnitude / r1.Magnitude / r2.Magnitude < 1e-10)
{
h12 = h1;
}
else
{
h12 = h12.Normalize();
}
// 根据初始角动量方向和始末位置的叉乘方向，计算转移轨道的转移角度theta，使其在[0,2*pi]范围内
// 也即确定转移轨道的角动量与初始角动量方向一致
double test_dir = h1.Dot(h12);
double theta = Math.Acos(cos_theta);
if (test_dir < 0)
{
theta = 2.0 * Math.PI - theta;
h12 = -h12;
}
// 求解Lambert方程
int n;
double vr11, vt11, vr12, vt12, vr21, vt21, vr22, vt22;
VLAMB(Gm, r1.Magnitude, r2.Magnitude, theta, tof, out n, out vr11, out vt11, out vr12, out vt12, out vr21, out vt21, out vr22, out vt22);
if (n != 1)
{
throw new Exception("单圈Lambert方程求解出错，解个数应为1!");
}
// 确定始末位置的单位速度方向(垂直于位置矢径)
UnitCartesian vi_ = h12.Cross(r1).Normalize();
UnitCartesian vf_ = h12.Cross(r2).Normalize();
// 解
dv1 = vt11 * vi_ + vr11 * r1.Normalize() - v1; //
dv2 = vt12 * vf_ + vr12 * r2.Normalize() - v2; //
dv1 = vt11 * vi_ + vr11 * r1.Normalize();
dv2 = vt12 * vf_ + vr12 * r2.Normalize();
}
public void TestInitializationFromBadArray()
{
double[] array = new double[2];
UnitCartesian first = new UnitCartesian(array, 0);
}
public void TestIndexTooHigh()
{
UnitCartesian first = new UnitCartesian(1.0, 2.0, 3.0);
double bad = first[3];
}
public void TestIndexTooLow()
{
UnitCartesian first = new UnitCartesian(1.0, 2.0, 3.0);
double bad = first[-1];
}
public void TestFromZero()
{
UnitCartesian first = new UnitCartesian(Cartesian.Zero);
}
public void TestEqualsEpsilon()
{
UnitCartesian first = new UnitCartesian(1.0, 1.0, 1.0);
UnitCartesian second = new UnitCartesian(0.99, 1.0, 1.01);
Assert.IsTrue(second.EqualsEpsilon(first, 1e-1));
Assert.IsTrue(second.EqualsEpsilon(first, 1e-2));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-3));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-4));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-5));
}
public void TestMostParallelAxis()
{
UnitCartesian Cartesian3 = new UnitCartesian(1.0, 2.0, 3.0);
Assert.AreEqual(UnitCartesian.UnitZ, Cartesian3.MostParallelAxis);
Cartesian3 = new UnitCartesian(2.0, 3.0, 1.0);
Assert.AreEqual(UnitCartesian.UnitY, Cartesian3.MostParallelAxis);
Cartesian3 = new UnitCartesian(3.0, 1.0, 2.0);
Assert.AreEqual(UnitCartesian.UnitX, Cartesian3.MostParallelAxis);
}
public void TestInvert()
{
UnitCartesian Cartesian3 = new UnitCartesian(2.0, 3.0, 6.0);
UnitCartesian inverted = Cartesian3.Invert();
Assert.AreEqual(-2.0 / 7.0, inverted.X);
Assert.AreEqual(-3.0 / 7.0, inverted.Y);
Assert.AreEqual(-6.0 / 7.0, inverted.Z);
}
public void TestEqualityWithWrongType()
{
UnitCartesian first = new UnitCartesian(1.0, 2.0, 3.0);
Cartographic second = new Cartographic(1.0, 2.0, 3.0);
Assert.IsFalse(first.Equals(second));
}
public void TestDotProduct()
{
UnitCartesian first = new UnitCartesian(1.0, 3.0, -2.0);
UnitCartesian second = new UnitCartesian(4.0, -2.0, -1.0);
Assert.AreEqual(0, first.Dot(second), Constants.Epsilon15);
Assert.AreEqual(0, second.Dot(first), Constants.Epsilon15);
Cartesian result = new Cartesian(4.0, -2.0, -1.0);
Assert.AreEqual(0, first.Dot(result));
}
public void TestMultiply()
{
UnitCartesian original = new UnitCartesian(2.0, 3.0, 6.0);
Cartesian multiplied = original * 7.0;
Assert.AreEqual(2.0, multiplied.X);
Assert.AreEqual(3.0, multiplied.Y);
Assert.AreEqual(6.0, multiplied.Z);
multiplied = 7.0 * original;
Assert.AreEqual(2.0, multiplied.X);
Assert.AreEqual(3.0, multiplied.Y);
Assert.AreEqual(6.0, multiplied.Z);
}
public void TestInitializationFromNull()
{
double[] array = null;
UnitCartesian first = new UnitCartesian(array, 0);
}
public void TestGetHashCode()
{
UnitCartesian object1 = new UnitCartesian(1.0, 2.0, 3.0);
UnitCartesian object2 = new UnitCartesian(1.0, 2.0, 3.0);
UnitCartesian object3 = new UnitCartesian(1.0, 2.0, 3.1);
Assert.AreEqual(object1.GetHashCode(), object2.GetHashCode());
Assert.AreNotEqual(object1.GetHashCode(), object3.GetHashCode());
}
/// <summary>
/// Writes a <see cref="UnitCartesian"/> value as an array in X, Y, Z order.
/// </summary>
/// <param name="output">The stream to which to write the value.</param>
/// <param name="value">The value to write.</param>
public static void WriteUnitCartesian3(CesiumOutputStream output, UnitCartesian value)
{
output.WriteStartSequence();
output.WriteValue(value.X);
output.WriteValue(value.Y);
output.WriteValue(value.Z);
output.WriteEndSequence();
}
public void TestToString()
{
UnitCartesian test1 = new UnitCartesian(1.0, 0.0, 0.0);
UnitCartesian test2 = new UnitCartesian(0.0, 1.0, 0.0);
UnitCartesian test3 = new UnitCartesian(0.0, 0.0, 1.0);
Assert.AreEqual("1, 0, 0", test1.ToString());
Assert.AreEqual("0, 1, 0", test2.ToString());
Assert.AreEqual("0, 0, 1", test3.ToString());
}
public void TestRotateByMatrix3By3()
{
double angle = Math.PI / 3.0; // half angle of 120 degree rotation
double cos = Math.Cos(angle);
double sin = Math.Sin(angle);
UnitCartesian axis = new UnitCartesian(1.0, 1.0, 1.0); // unit vector along [1,1,1]
double w = cos;
double x = sin * axis.X;
double y = sin * axis.Y;
double z = sin * axis.Z;
// The original vector is along the x-axis.
UnitCartesian original = new UnitCartesian(1.0, 0.0, 0.0);
// The rotated vector is along the z-axis.
UnitCartesian rotated = original.Rotate(new Matrix3By3(new UnitQuaternion(w, x, y, z)));
Assert.AreEqual(0.0, rotated.X, Constants.Epsilon15);
Assert.AreEqual(0.0, rotated.Y, Constants.Epsilon15);
Assert.AreEqual(1.0, rotated.Z, Constants.Epsilon15);
}
public void TestMatrixReturns()
{
double x = 1;
double y = 2;
double z = 3;
Matrix3By3 mat1 = Matrix3By3.CrossProductEquivalentMatrix(new Cartesian(x, y, z));
Assert.AreEqual(0.0, mat1.M11);
Assert.AreEqual(-z, mat1.M12);
Assert.AreEqual(y, mat1.M13);
Assert.AreEqual(z, mat1.M21);
Assert.AreEqual(0, mat1.M22);
Assert.AreEqual(-x, mat1.M23);
Assert.AreEqual(-y, mat1.M31);
Assert.AreEqual(x, mat1.M32);
Assert.AreEqual(0.0, mat1.M33);
UnitCartesian u = new UnitCartesian(x, y, z);
x = u.X;
y = u.Y;
z = u.Z;
Matrix3By3 mat2 = Matrix3By3.CrossProductEquivalentMatrix(u);
Assert.AreEqual(0.0, mat2.M11);
Assert.AreEqual(-z, mat2.M12);
Assert.AreEqual(y, mat2.M13);
Assert.AreEqual(z, mat2.M21);
Assert.AreEqual(0, mat2.M22);
Assert.AreEqual(-x, mat2.M23);
Assert.AreEqual(-y, mat2.M31);
Assert.AreEqual(x, mat2.M32);
Assert.AreEqual(0.0, mat2.M33);
Matrix3By3 mat3 = Matrix3By3.DiagonalMatrix(new Cartesian(1, 2, 3));
Assert.AreEqual(mat3.M11, 1);
Assert.AreEqual(mat3.M22, 2);
Assert.AreEqual(mat3.M33, 3);
Matrix3By3 mat4 = Matrix3By3.DiagonalMatrix(new UnitCartesian(1, 0, 0));
Assert.AreEqual(mat4.M11, 1);
Assert.AreEqual(mat4.M22, 0);
Assert.AreEqual(mat4.M33, 0);
}
public void TestAngleBetween()
{
double fortyFiveDegrees = Math.PI / 4.0;
UnitCartesian first = new UnitCartesian(1.0, 1.0, 0.0);
UnitCartesian second = new UnitCartesian(1.0, 1.0, Math.Sqrt(2.0));
Assert.AreEqual(fortyFiveDegrees, second.AngleBetween(first), Constants.Epsilon15);
}
public void TestEquality()
{
UnitCartesian first = new UnitCartesian(1.0, 2.0, 3.0);
UnitCartesian second = new UnitCartesian(1.0, 2.0, 3.0);
Assert.AreEqual(first, second);
Assert.AreEqual(second, first);
Assert.IsTrue(first == second);
Assert.IsTrue(second == first);
Assert.IsFalse(first != second);
Assert.IsFalse(second != first);
Assert.IsTrue(first.Equals(second));
Assert.IsTrue(second.Equals(first));
second = new UnitCartesian(0.0, 2.0, 3.0);
Assert.AreNotEqual(first, second);
Assert.AreNotEqual(second, first);
Assert.IsFalse(first == second);
Assert.IsFalse(second == first);
Assert.IsTrue(first != second);
Assert.IsTrue(second != first);
Assert.IsFalse(first.Equals(second));
Assert.IsFalse(second.Equals(first));
second = new UnitCartesian(1.0, 0.0, 3.0);
Assert.AreNotEqual(first, second);
Assert.AreNotEqual(second, first);
Assert.IsFalse(first == second);
Assert.IsFalse(second == first);
Assert.IsTrue(first != second);
Assert.IsTrue(second != first);
Assert.IsFalse(first.Equals(second));
Assert.IsFalse(second.Equals(first));
second = new UnitCartesian(1.0, 2.0, 0.0);
Assert.AreNotEqual(first, second);
Assert.AreNotEqual(second, first);
Assert.IsFalse(first == second);
Assert.IsFalse(second == first);
Assert.IsTrue(first != second);
Assert.IsTrue(second != first);
Assert.IsFalse(first.Equals(second));
Assert.IsFalse(second.Equals(first));
}
public void TestFromClockAndCone()
{
double fortyFiveDegrees = Math.PI / 4.0;
double thirtyDegrees = Math.PI / 6.0;
UnitCartesian test = new UnitCartesian(thirtyDegrees, fortyFiveDegrees);
Assert.AreEqual(Math.Sqrt(3.0) / Math.Sqrt(8.0), test.X, Constants.Epsilon15);
Assert.AreEqual(1.0 / Math.Sqrt(8.0), test.Y, Constants.Epsilon15);
Assert.AreEqual(1.0 / Math.Sqrt(2.0), test.Z, Constants.Epsilon15);
}
public void TestFromInfinity()
{
UnitCartesian first = new UnitCartesian(Double.PositiveInfinity, 0.0, 0.0);
}
