public Cartesian3 Cross(Cartesian3 left, Cartesian3 right)
{
checkCartesian3(left);
checkCartesian3(right);
return(this.cross(left, right));
}
/// <summary>
/// 对Cartesian3执行检查(只检查是否为null)
/// </summary>
/// <param name="cartesian3"></param>
private void checkCartesian3(Cartesian3 cartesian3)
{
if (cartesian3 == null)
{
throw new ArgumentNullException("Cartesian3");
}
}
public Cartesian3 MaximumByComponent(Cartesian3 first, Cartesian3 second)
{
checkCartesian3(first);
checkCartesian3(second);
return(this.maximumByComponent(first, second));
}
public Cartesian3 Lerp(Cartesian3 start, Cartesian3 end, double scalar)
{
checkCartesian3(start);
checkCartesian3(end);
YzgMath.CheckNumber_ButweenLeftRight_EqualLeftRight(scalar, 0.0, 1.0);
return(this.lerp(start, end, scalar));
}
public double AngleBetween(Cartesian3 left, Cartesian3 right)
{
checkCartesian3(left);
checkCartesian3(right);
return(this.angleBetween(left, right));
}
public double DistanceSquared(Cartesian3 left, Cartesian3 right)
{
checkCartesian3(left);
checkCartesian3(right);
return(this.distanceSquared(left, right));
}
public Cartesian3 DivideComponents(Cartesian3 left, Cartesian3 right)
{
checkCartesian3(left);
checkCartesian3_NotEqualTo(right, 0.0);
return(this.multiplyComponents(left, right));
}
public Cartesian3 MultiplyComponents(Cartesian3 left, Cartesian3 right)
{
checkCartesian3(left);
checkCartesian3(right);
return(this.multiplyComponents(left, right));
}
private Cartesian3 lerp(Cartesian3 start, Cartesian3 end, double scalar)
{
Cartesian3 multiplyStart = this.multiplyByScalar(start, 1.0 - scalar);
Cartesian3 multiplyEnd = this.multiplyByScalar(end, scalar);
return(this.add(multiplyStart, multiplyEnd));
}
public Cartesian3 Add(Cartesian3 left, Cartesian3 right)
{
checkCartesian3(left);
checkCartesian3(right);
return(this.add(left, right));
}
public Cartesian3 Subtract(Cartesian3 left, Cartesian3 right)
{
checkCartesian3(left);
checkCartesian3(right);
return(this.subtract(left, right));
}
private Cartesian3 mostOrthogonalAxis(Cartesian3 cartesian3)
{
Cartesian3 normalizeCartesian3 = this.normalize(cartesian3);
Cartesian3 absCartesian3 = this.abs(normalizeCartesian3);
Cartesian3 result = null;
if (absCartesian3.X <= absCartesian3.Y)
{
if (absCartesian3.X <= absCartesian3.Z)
{
result = this.getCartesian3_UNIT_X();
}
else
{
result = this.getCartesian3_UNIT_Z();
}
}
else if (absCartesian3.Y <= absCartesian3.Z)
{
result = this.getCartesian3_UNIT_Y();
}
else
{
result = this.getCartesian3_UNIT_Z();
}
return(result);
}
public double Dot(Cartesian3 left, Cartesian3 right)
{
checkCartesian3(left);
checkCartesian3(right);
return(this.dot(left, right));
}
private Cartesian3 abs(Cartesian3 cartesian3)
{
double resultX = Math.Abs(cartesian3.X);
double resultY = Math.Abs(cartesian3.Y);
double resultZ = Math.Abs(cartesian3.Z);
return(new Cartesian3(resultX, resultY, resultZ));
}
private Cartesian3 negate(Cartesian3 cartesian3)
{
double resultX = -cartesian3.X;
double resultY = -cartesian3.Y;
double resultZ = -cartesian3.Z;
return(new Cartesian3(resultX, resultY, resultZ));
}
private Cartesian3 divideByScalar(Cartesian3 cartesian3, double scalar)
{
double resultX = cartesian3.X / scalar;
double resultY = cartesian3.Y / scalar;
double resultZ = cartesian3.Z / scalar;
return(new Cartesian3(resultX, resultY, resultZ));
}
private Cartesian3 multiplyByScalar(Cartesian3 cartesian3, double scalar)
{
double resultX = cartesian3.X * scalar;
double resultY = cartesian3.Y * scalar;
double resultZ = cartesian3.Z * scalar;
return(new Cartesian3(resultX, resultY, resultZ));
}
private Cartesian3 divideComponents(Cartesian3 left, Cartesian3 right)
{
double resultX = left.X / right.X;
double resultY = left.Y / right.Y;
double resultZ = left.Z / right.Z;
return(new Cartesian3(resultX, resultY, resultZ));
}
private Cartesian3 minimumByComponent(Cartesian3 first, Cartesian3 second)
{
double resultX = Math.Min(first.X, second.X);
double resultY = Math.Min(first.Y, second.Y);
double resultZ = Math.Min(first.Z, second.Z);
return(new Cartesian3(resultX, resultY, resultZ));
}
private Cartesian3 subtract(Cartesian3 left, Cartesian3 right)
{
double resultX = left.X - right.X;
double resultY = left.Y - right.Y;
double resultZ = left.Z - right.Z;
return(new Cartesian3(resultX, resultY, resultZ));
}
private Cartesian3 add(Cartesian3 left, Cartesian3 right)
{
double resultX = left.X + right.X;
double resultY = left.Y + right.Y;
double resultZ = left.Z + right.Z;
return(new Cartesian3(resultX, resultY, resultZ));
}
private Cartesian3 cross(Cartesian3 left, Cartesian3 right)
{
double resultX = left.Y * right.Z - left.Z * right.Y;
double resultY = left.Z * right.X - left.X * right.Z;
double resultZ = left.X * right.Y - left.Y * right.X;
return(new Cartesian3(resultX, resultY, resultZ));
}
private Cartesian3 multiplyComponents(Cartesian3 left, Cartesian3 right)
{
double resultX = left.X * right.X;
double resultY = left.Y * right.Y;
double resultZ = left.Z * right.Z;
return(new Cartesian3(resultX, resultY, resultZ));
}
private double angleBetween(Cartesian3 left, Cartesian3 right)
{
Cartesian3 normalizeLeft = this.normalize(left);
Cartesian3 normalizeRight = this.normalize(right);
double cosine = this.dot(normalizeLeft, normalizeRight);
double sine = this.magnitude(this.cross(normalizeLeft, normalizeRight));
return(Math.Atan2(sine, cosine));
}
private Cartesian3 normalize(Cartesian3 cartesian3)
{
double magnitude = this.magnitude(cartesian3);
double resultX = cartesian3.X / magnitude;
double resultY = cartesian3.Y / magnitude;
double resultZ = cartesian3.Z / magnitude;
return(new Cartesian3(resultX, resultY, resultZ));
}
/// <summary>
/// 笛卡尔坐标转投影坐标(y+500Km;x,y交换)
/// </summary>
/// <param name="gaussianPoint"></param>
/// <returns></returns>
public Projection CartesianToProjection(Cartesian3 gaussianPoint)
{
Projection result = new Projection();
result.x = gaussianPoint.Y + 500000;
result.y = gaussianPoint.X;
result.z = gaussianPoint.Z;
return(result);
}
public Cartographic3 Cartesian3ToCartographic3(Cartesian3 cartesian3)
{
if (cartesian3 == null)
{
throw new ArgumentNullException("Cartesian3");
}
Ellipsoid ellipsoid = CoordinateSystem.WGS84.GetEllipsoid();
return(this.fromCartesian(cartesian3, ellipsoid));
}
/// <summary>
/// 投影坐标转笛卡尔坐标(x,y交换;y-500Km)
/// </summary>
/// <param name="planePoint"></param>
/// <returns></returns>
public Cartesian3 ProjectionToCartesian(Projection projectionPoint)
{
Cartesian3 result = new Cartesian3();
result.X = projectionPoint.y;
result.Y = projectionPoint.x - 500000;
result.Z = projectionPoint.z;
return(result);
}
/// <summary>
/// 对Cartesian3执行检查(xyz属性需要小于等于standard)
/// </summary>
/// <param name="cartesian3"></param>
/// <param name="standard"></param>
private void checkCartesian3_LessThanOrEqualTo(Cartesian3 cartesian3, double standard)
{
if (cartesian3 == null)
{
throw new ArgumentNullException("Cartesian3");
}
if (cartesian3.X > standard || cartesian3.Y > standard || cartesian3.Z > standard)
{
throw new ArgumentOutOfRangeException("Cartesian3的XYZ属性需要小于等于" + standard);
}
}
/// <summary>
/// 对Cartesian3执行检查(xyz属性不能等于standard)
/// </summary>
/// <param name="cartesian3"></param>
/// <param name="standard"></param>
private void checkCartesian3_NotEqualTo(Cartesian3 cartesian3, double standard)
{
if (cartesian3 == null)
{
throw new ArgumentNullException("Cartesian3");
}
if (cartesian3.X == standard || cartesian3.Y == standard || cartesian3.Z == standard)
{
throw new ArgumentOutOfRangeException("Cartesian3的XYZ属性不能等于" + standard);
}
}
