public void Calculate_SetsVectorInCartesian_ForGivenValues(
double radius,
double phiInRadians,
double polarThetaInRadians,
double expectedX,
double expectedY,
double expectedZ)
{
// Arrange
var sut = new SphericalToCartesianCalculator();
var expected = new CartesianCoordinates
{
X = expectedX,
Y = expectedY,
Z = expectedZ
};
var sphericalCoordinates = new SphericalCoordinates
{
Radius = radius,
Phi = Angle.FromRadians(phiInRadians),
Theta = Angle.FromRadians(polarThetaInRadians)
};
sut.SphericalCoordinates = sphericalCoordinates;
// Act
sut.Calculate();
// Assert
CartesianCoordinatesHelper.AssertCartesianCoordinates(expected,
sut.CartesianCoordinates);
}
private IEnumerable <CartesianCoordinates> CreateCoordinatesCaseTwoClockwise()
{
var one = new CartesianCoordinates
{
X = +0.0,
Y = +0.0,
Z = -1.0
};
var two = new CartesianCoordinates
{
X = -1.0,
Y = +0.0,
Z = +0.0
};
var three = new CartesianCoordinates
{
X = +0.0,
Y = +0.0,
Z = +1.0
};
return(new[]
{
one,
two,
three
});
}
public HorizontalCoordinates ToHorizontalCoordinates(Radian latitude, Radian longitude, DateTime utcTime)
{
var hourAngle = new SunInfoCalculator(utcTime).HourAngle(longitude);
double rightSide1 = Math.Sin(latitude.Value) * Math.Sin(Declination.Value) +
Math.Cos(latitude.Value) * Math.Cos(Declination.Value) * Math.Cos(hourAngle.Value);
double rightSide2 = Math.Cos(latitude.Value) * Math.Sin(Declination.Value) -
Math.Sin(latitude.Value) * Math.Cos(Declination.Value) * Math.Cos(hourAngle.Value);
double rightSide3 = -Math.Cos(Declination.Value) * Math.Sin(hourAngle.Value);
PolarCoordinates polarCoordinates = new CartesianCoordinates(rightSide2, rightSide3).ToPolarCoordinates();
var azimuth = polarCoordinates.Angle;
if (azimuth.Value < 0)
{
azimuth = new Degree(360.0).ToRadian() - (-azimuth);
}
polarCoordinates = new CartesianCoordinates(polarCoordinates.Radius, rightSide1).ToPolarCoordinates();
var altitude = polarCoordinates.Angle;
double mustBe1 = polarCoordinates.Radius;
return new HorizontalCoordinates(azimuth, altitude);
}
private IEnumerable <CartesianCoordinates> CreateCoordinatesCaseThreeCounterClockwise()
{
var one = new CartesianCoordinates
{
X = 1.0,
Y = 1.0,
Z = 1.0
};
var two = new CartesianCoordinates
{
X = -1.22474487139159,
Y = +1.22474487139159,
Z = +0.0
};
var three = new CartesianCoordinates
{
X = -1.0,
Y = -1.0,
Z = -1.0
};
return(new[]
{
one,
two,
three
});
}
public void UpdateElevations(GeographicBounds bounds)
{
// iterate through all models in bounds and update elevation
var coords = new CartesianCoordinates();
foreach (var node in DataByNode)
{
if (node.Key.GeographicBounds.MinimumCoordinates.Latitude > bounds.MaximumCoordinates.Latitude)
{
continue;
}
if (node.Key.GeographicBounds.MinimumCoordinates.Longitude > bounds.MaximumCoordinates.Longitude)
{
continue;
}
if (node.Key.GeographicBounds.MaximumCoordinates.Latitude < bounds.MinimumCoordinates.Latitude)
{
continue;
}
if (node.Key.GeographicBounds.MaximumCoordinates.Longitude < bounds.MinimumCoordinates.Longitude)
{
continue;
}
foreach (var go in node.Value.GameObjects)
{
var position = go.transform.position;
coords.X = position.x;
coords.Y = position.z;
var location = coords.TransformedWith(Database.Projection);
float elev = Database.TerrainElevationAtLocation(location);
go.transform.position = new Vector3(position.x, elev, position.z);
}
}
}
public void Calculate_SetsCartesianCoordinates_CaseTwoCounterClockwise()
{
// Arrange
IEnumerable <CartesianCoordinates> expected = CreateCoordinatesCaseTwoCounterClockwise();
var coordinatesZeroZeroOne = new CartesianCoordinates
{
X = 0.0,
Y = 0.0,
Z = -1.0
};
var coordinatesOneZeroZero = new CartesianCoordinates
{
X = 0.0,
Y = 0.0,
Z = 1.0
};
m_Sut.FromCoordinates = coordinatesZeroZeroOne;
m_Sut.ToCoordinates = coordinatesOneZeroZero;
m_Sut.TurnDirection = Constants.TurnDirection.Counterclockwise;
m_Sut.Steps = 3;
// Act
m_Sut.Calculate();
// Assert
CartesianCoordinatesHelper.AssertSphericalCoordinates(expected,
m_Sut.CartesianCoordinates);
}
protected void Update()
{
if (Database != null && UserObject != null)
{
Database.ApplyCameraPosition(UserObject.transform.position);
if (AltitudeText != null)
{
float altitudeInMeters = UserObject.transform.position.y * 10;
AltitudeText.text = string.Format("m: {0:N2}, ft: {1:N2}, FL: {2:N2}", altitudeInMeters, altitudeInMeters * Cognitics.UnityCDB.VolumetricFeature.feetPerMeter, altitudeInMeters * Cognitics.UnityCDB.VolumetricFeature.feetPerMeter * Cognitics.UnityCDB.VolumetricFeature.flightLevelPerFoot);
}
}
if (CameraPositionPanel != null)
{
CameraPosition campos = CameraPositionPanel.GetComponent <CameraPosition>();
float x = UserObject.transform.position.x;
float z = UserObject.transform.position.z;
var cartesianCoordinates = new CartesianCoordinates(x, z);
var geographicCoordinates = cartesianCoordinates.TransformedWith(Database.Projection);
campos.position.x = (float)geographicCoordinates.Longitude;
campos.position.z = (float)geographicCoordinates.Latitude;
campos.position.y = UserObject.transform.position.y / (float)Database.Projection.Scale;
}
}
private IEnumerable <CartesianCoordinates> CreateCoordinatesCaseOneCounterClockwise()
{
var one = new CartesianCoordinates
{
X = 0.0,
Y = 0.0,
Z = 1.0
};
var two = new CartesianCoordinates
{
X = -0.707106781186547,
Y = 0.0,
Z = -0.707106781186547
};
var three = new CartesianCoordinates
{
X = 1.0,
Y = 0.0,
Z = 0.0
};
return(new[]
{
one,
two,
three
});
}
private SphericalCoordinates ToSpherical(CartesianCoordinates cartesianCoordinates)
{
m_CartesianToSphericalCalculator.CartesianCoordinates = cartesianCoordinates;
m_CartesianToSphericalCalculator.Calculate();
return(m_CartesianToSphericalCalculator.SphericalCoordinates);
}
private IEnumerable <CartesianCoordinates> CreateCoordinatesCaseFourCounterClockwise()
{
var circle = new Circle(0.0,
0.0,
1.0);
Point from = circle.PointOnCircle(Angle.For315Degrees);
Point to = circle.PointOnCircle(Angle.For45Degrees);
Point middle = circle.PointOnCircle(Angle.For180Degrees);
var one = new CartesianCoordinates
{
X = from.X,
Y = from.Y,
Z = 0.0
};
var two = new CartesianCoordinates
{
X = middle.X,
Y = middle.Y,
Z = 0.0
};
var three = new CartesianCoordinates
{
X = to.X,
Y = to.Y,
Z = 0.0
};
return(new[]
{
one,
two,
three
});
}
public void VerticallLineShouldNotContainElementsNotInItsPath()
{
var p0 = new CartesianCoordinates(6, 10);
var p1 = new CartesianCoordinates(6, -12);
var line = new Line(p0, p1);
line.Contains(new CartesianCoordinates(5, 0)).Should().BeFalse();
}
public void HorizontalLineShouldNotContainElementsNotInItsPath()
{
var p0 = new CartesianCoordinates(1, 0);
var p1 = new CartesianCoordinates(-6, 0);
var line = new Line(p0, p1);
line.Contains(new CartesianCoordinates(10, 0.00000000000001)).Should().BeFalse();
}
public void NegativeSlopeLineShouldNotContainElementsNotInItsPath()
{
var p0 = new CartesianCoordinates(1.5, 0);
var p1 = new CartesianCoordinates(0, 6);
var line = new Line(p0, p1);
line.Contains(new CartesianCoordinates(0.76, 2.97)).Should().BeFalse();
}
public void GetNeighborsTests(int range, List <Point> expected)
{
var point = new Point(3, 3);
var actual = CartesianCoordinates.GetNeighbors(point, range, this.points);
CollectionAssert.AreEquivalent(expected, actual);
}
public void PositiveopeLineShouldNotContainElementsNotInItsPath()
{
var p0 = new CartesianCoordinates(0.03, 2.8);
var p1 = new CartesianCoordinates(-0.044, -1.64);
var line = new Line(p0, p1);
line.Contains(new CartesianCoordinates(-0.069, -3.1399999999999999)).Should().BeTrue();
}
public void GetNeighbors_RangeLessOrEqualsZero_ThrowArgumentException()
{
var point = new Point();
int range = -1;
Assert.Throws <ArgumentException>(() => CartesianCoordinates.GetNeighbors(point, range, this.points),
message: "Range cannot be less or equals zero.");
}
public void CartesianPrecisionEqualsTest()
{
var a = new CartesianCoordinates(0, 0);
var b = new CartesianCoordinates(0.000000001, 0.000000001);
Assert.True(a.Equals(b, 5));
Assert.False(a.Equals(b));
}
public static void EditTransform(this Transform trans, CartesianCoordinates coOrd, bool bChangeX = false, bool bChangeY = false, bool bChangeZ = false)
{
float tempX = bChangeX ? coOrd.x : trans.position.x;
float tempY = bChangeY ? coOrd.y : trans.position.y;
float tempZ = bChangeZ ? coOrd.z : trans.position.z;
trans.position = new Vector3(tempX, tempY, tempZ);
}
public void GetNeighbors_PointsIsEqualNull_ThrowArgumentNullException()
{
var point = new Point();
int range = 1;
points = null;
Assert.Throws <ArgumentNullException>(() => CartesianCoordinates.GetNeighbors(point, range, this.points),
message: "Points cannot be equals null.");
}
public void Triangle_Should_Do_A_Proper_Calculation_Of_Its_Perimeter()
{
var p0 = new CartesianCoordinates(0, 0);
var p1 = new CartesianCoordinates(2, 0);
var p2 = new CartesianCoordinates(0, 2);
var triangle = new Triangle(p0, p1, p2);
triangle.GetPerimeter().Should().Be(4 + Math.Sqrt(8));
}
public bool Contains(CartesianCoordinates point)
{
var Area = ((double)1 / 2) * (-point1.Y * point2.X + point0.Y * (-point1.X + point2.X) + point0.X * (point1.Y - point2.Y) + point1.X * point2.Y);
var sign = Area < 0 ? -1 : 1;
var s = (point0.Y * point2.X - point0.X * point2.Y + (point2.Y - point0.Y) * point.X + (point0.X - point2.X) * point.Y) * sign;
var t = (point0.X * point1.Y - point0.Y * point1.X + (point0.Y - point1.Y) * point.X + (point1.X - point0.X) * point.Y) * sign;
return(s > 0 && t > 0 && (s + t) < 2 * Area * sign);
}
public void CartesianToPolarToCartesian()
{
var cartesian = new CartesianCoordinates(10, 2);
var polar = cartesian.ToPolar();
var newCartesian = polar.ToCartesian();
Assert.Equal(cartesian.X, newCartesian.X, 10);
Assert.Equal(cartesian.Y, newCartesian.Y, 10);
}
/// <summary>
/// count point distance from line
/// </summary>
/// <param name="point">point coordinates</param>
/// <param name="line">line parameters</param>
/// <returns>distance</returns>
public double CountDistance(CartesianCoordinates point, Line line)
{
double parameter = (line.direction.X * (point.x - line.point.X) + line.direction.Y * (point.y - line.point.Y) + line.direction.Z * (point.z - line.point.Z)) / (Math.Pow(line.direction.X, 2) + Math.Pow(line.direction.Y, 2) + Math.Pow(line.direction.Z, 2));
double xNew = line.point.X + line.direction.X * parameter;
double yNew = line.point.Y + line.direction.Y * parameter;
double zNew = line.point.Z + line.direction.Z * parameter;
return(Math.Sqrt(Math.Pow(xNew - point.x, 2) + Math.Pow(yNew - point.y, 2) + Math.Pow(zNew - point.z, 2)));
}
private void PolygonPictureBox_Click(object sender, EventArgs e)
{
MouseEventArgs mouseClick = (MouseEventArgs)e;
var point = new CartesianCoordinates(
(double)(mouseClick.X - 200) / (double)ZoomNumericUpDown.Value,
(double)(-mouseClick.Y + 200) / (double)ZoomNumericUpDown.Value);
AddPoint(point);
}
public void Setup()
{
m_Sut = new CartesianCoordinates
{
X = 1.0,
Y = 2.0,
Z = 3.0,
IsUnknown = true
};
}
public void Triangle_Should_Not_Contain_Points_On_Its_Edges()
{
var p0 = new CartesianCoordinates(0, 0);
var p1 = new CartesianCoordinates(2, 0);
var p2 = new CartesianCoordinates(0, 2);
var triangle = new Triangle(p0, p1, p2);
triangle.Contains(new CartesianCoordinates(1, 1)).Should().BeFalse();
triangle.Contains(new CartesianCoordinates(0, 0.5)).Should().BeFalse();
triangle.Contains(new CartesianCoordinates(1, 0)).Should().BeFalse();
}
public bool Contains(CartesianCoordinates checkPoint)
{
if (this.isVertical)
{
return(checkPoint.X == this.xValue);
}
else
{
return(Convert.ToDecimal(checkPoint.Y) == this.slope * Convert.ToDecimal(checkPoint.X) + this.yIntercept);
}
}
public void Triangle_Should_Not_Contain_Its_Vertices()
{
var p0 = new CartesianCoordinates(0, 0);
var p1 = new CartesianCoordinates(2, 0);
var p2 = new CartesianCoordinates(0, 2);
var triangle = new Triangle(p0, p1, p2);
triangle.Contains(p0).Should().BeFalse();
triangle.Contains(p1).Should().BeFalse();
triangle.Contains(p2).Should().BeFalse();
}
public void Triangle_Should_Contain_Points_Inside_It()
{
var p0 = new CartesianCoordinates(0, 0);
var p1 = new CartesianCoordinates(2, 0);
var p2 = new CartesianCoordinates(0, 2);
var triangle = new Triangle(p0, p1, p2);
triangle.Contains(new CartesianCoordinates(0.99999999999999, 0.99999999999999)).Should().BeTrue();
triangle.Contains(new CartesianCoordinates(0.00000000000001, 0.00000000000001)).Should().BeTrue();
triangle.Contains(new CartesianCoordinates(0.5, 0.5)).Should().BeTrue();
}
public static string CoordinatesToString(
CartesianCoordinates coordinates)
{
var converter = new CartesianCoordinatesToStringConverter
{
Coordinates = coordinates
};
converter.Convert();
return(converter.String);
}
private Point()
{
var data = new CartesianCoordinates
{
X = double.NaN,
Y = double.NaN,
Z = double.NaN,
IsUnknown = true
};
Coordinates = data;
}
