/// <summary>
/// Extension method for parsing trajectory.
/// </summary>
/// <param name="trajectoryNode">Node with trajectory</param>
/// <returns>Trajectory from xml.</returns>
public static Trajectory ParseTrajectory(this XmlNode trajectoryNode)
{
Direction direction;
if (trajectoryNode.FirstChild.Attributes["direction"] == null)
{
direction = Direction.CLOCKWISE;
}
else
{
string directionString = trajectoryNode.FirstChild.Attributes["direction"].Value;
if (directionString.Equals("clockwise"))
{
direction = Direction.CLOCKWISE;
}
else
{
direction = Direction.COUNTERCLOCKWISE;
}
}
Trajectory trajectory = null;
switch (trajectoryNode.FirstChild.Name.ToLowerInvariant())
{
case "stacionary":
int x = trajectoryNode.FirstChild.Attributes["x"].IntValue();
int y = trajectoryNode.FirstChild.Attributes["y"].IntValue();
trajectory = new Stacionary(x, y);
break;
case "circularorbit":
{
int radius = trajectoryNode.FirstChild.Attributes["radius"].IntValue();
double initialAngle = trajectoryNode.FirstChild.Attributes["initialAngle"].DoubleValue();
int period = trajectoryNode.FirstChild.Attributes["period"].IntValue();
trajectory = new CircularOrbit(radius, period, direction, initialAngle);
}
break;
case "ellipticorbit":
{
int a = trajectoryNode.FirstChild.Attributes["a"].IntValue();
int b = trajectoryNode.FirstChild.Attributes["b"].IntValue();
double rotationAngle = trajectoryNode.FirstChild.Attributes["angle"].DoubleValue();
double initialAngle = trajectoryNode.FirstChild.Attributes["initialAngle"].DoubleValue();
int period = trajectoryNode.FirstChild.Attributes["period"].IntValue();
trajectory = new EllipticOrbit(new Point2d(0.0, 0.0), a, b, rotationAngle, period, direction, initialAngle);
}
break;
default:
throw new XmlException("Unexpected trajectory.");
}
return(trajectory);
}
public void ParseTrajectoryTest_Elliptic()
{
//string[] trajectoryParams = { "velocity", "5", "direction", "clockwise" };
string[] ellipseParams = { "velocity", "5", "direction", "clockwise", "x", "10", "y", "20", "a", "40", "b", "30", "initialAngle", "90", "angle", "100", "period", "5" };
EllipticOrbit expectedOrbit = new EllipticOrbit(new Point2d(0, 0), 40, 30, 100, 5, Direction.CLOCKWISE, 90);
XmlNode trajectoryNode = this.GenerateTrajectoryNode("ellipticOrbit", ellipseParams);
Trajectory trajectory = trajectoryNode.ParseTrajectory();
AssertEqualsEllipticOrbit(expectedOrbit, trajectory);
}
public void EllipticOrbitRotationTest()
{
int period = 150;
bool check = false;
int accuracy = 5;
EllipticOrbit testOrbit = new EllipticOrbit(new Point2d(0, 0), 50, 40, 30, period, Direction.COUNTERCLOCKWISE, 54);
EllipticOrbit testOrbit2 = new EllipticOrbit(new Point2d(0, 0), 50, 40, 390, period, Direction.COUNTERCLOCKWISE, 54);
Point2d orbitIn0 = this.RoundCoords(testOrbit.CalculatePosition(0), accuracy);
Point2d orbit2In0 = this.RoundCoords(testOrbit2.CalculatePosition(0), accuracy);
check = Debug.Equals(orbitIn0, orbit2In0);
Debug.Assert(check, "Elliptic rotation test failed!");
}
private void AssertEqualsEllipticOrbit(EllipticOrbit expected, object actual)
{
Assert.IsNotNull(actual);
Assert.IsInstanceOfType(actual, typeof(EllipticOrbit));
EllipticOrbit ellipticOrbit = (EllipticOrbit)actual;
Assert.AreEqual(5d, ellipticOrbit.PeriodInSec);
Assert.AreEqual(Direction.CLOCKWISE, ellipticOrbit.Direction, "Invalid orbit direction");
Assert.AreEqual(expected.Barycenter.X, ellipticOrbit.Barycenter.X);
Assert.AreEqual(expected.Barycenter.Y, ellipticOrbit.Barycenter.Y);
Assert.AreEqual(expected.A, ellipticOrbit.A);
Assert.AreEqual(expected.B, ellipticOrbit.B);
Assert.AreEqual(expected.InitialAngleRad, ellipticOrbit.InitialAngleRad);
Assert.AreEqual(expected.RotationAngleInRad, ellipticOrbit.RotationAngleInRad);
}
/// <summary>
/// Metoda nastavujici excentricitu orbity, je zde potreba velke mnozstvi matematiky, protoze pri zmene excentricity muze dojit ke zmene typu objektu
/// </summary>
/// <param name="newEccentricity">Nova excentricita</param>
public void SetOrbitalEccentricity(double newEccentricity)
{
//TODO: Improve this math
if (newEccentricity < 0 || newEccentricity >= 1)
{
throw new ArgumentOutOfRangeException("Kruh ma excentricitu 1, elipsa ma excentricitu v intervalu (0,1)");
}
TryToSet();
//Nasledujici metody nejsou moc presne jelikoz transformace kruhu na ellipsu neni trivialni zalezitost
if (LoadedObject is EllipticOrbit)
{
int newB = (int)Math.Round(Math.Sqrt(((EllipticOrbit)LoadedObject).A * ((EllipticOrbit)LoadedObject).A - newEccentricity * newEccentricity));
if (newB == 0)
{
CircularOrbit newOrbit = new CircularOrbit(0, 0, Direction.CLOCKWISE, 0);
newOrbit.PeriodInSec = (int)((EllipticOrbit)LoadedObject).PeriodInSec;
newOrbit.Radius = ((EllipticOrbit)LoadedObject).A;
newOrbit.Direction = ((EllipticOrbit)LoadedObject).Direction;
newOrbit.InitialAngleRad = ((EllipticOrbit)LoadedObject).InitialAngleRad;
LoadedObject = newOrbit;
}
else
{
((EllipticOrbit)LoadedObject).OrbitalEccentricity = newEccentricity;
((EllipticOrbit)LoadedObject).B = newB;
}
}
if (LoadedObject is CircularOrbit)
{
if (newEccentricity > 0 && newEccentricity < 1)
{
EllipticOrbit newOrbit = new EllipticOrbit(new Point2d(0, 0), 0, 0, 0, 0, Direction.CLOCKWISE, 0);
newOrbit.Barycenter = new Point2d(0, 0);
newOrbit.A = ((CircularOrbit)LoadedObject).Radius;
newOrbit.B = (int)Math.Round(Math.Sqrt(newOrbit.A * newOrbit.A - newEccentricity * newEccentricity));
//TODO: Correct transformation from circle to ellipse and backwards
newOrbit.RotationAngleInRad = 0;
newOrbit.PeriodInSec = ((CircularOrbit)LoadedObject).PeriodInSec;
newOrbit.Direction = ((CircularOrbit)LoadedObject).Direction;
newOrbit.InitialAngleRad = ((CircularOrbit)LoadedObject).InitialAngleRad;
}
}
}
public void EllipticOrbit3Test()
{
int period = 150;
bool check = false;
int accuracy = 5;
String testOrbitDefinition = "Elliptic CW orbit with initial angle";
EllipticOrbit testOrbit = new EllipticOrbit(new Point2d(0, 0), 50, 40, 0, period, Direction.CLOCKWISE, 55);
Point2d orbitIn0 = this.RoundCoords(testOrbit.CalculatePosition(0), accuracy);
Point2d orbitInT = this.RoundCoords(testOrbit.CalculatePosition(period), accuracy);
Point2d orbitIn2T = this.RoundCoords(testOrbit.CalculatePosition(2 * period), accuracy);
Point2d orbitIn5T = this.RoundCoords(testOrbit.CalculatePosition(5 * period), accuracy);
Point2d orbitIn10T = this.RoundCoords(testOrbit.CalculatePosition(10 * period), accuracy);
check = Debug.Equals(orbitIn0, orbitInT);
Debug.Assert(check, testOrbitDefinition + " calculated position isn't same in 0 and T");
check = Debug.Equals(orbitIn0, orbitIn2T);
Debug.Assert(check, testOrbitDefinition + " calculated position isn't same in 0 and 2*T");
check = Debug.Equals(orbitIn0, orbitIn5T);
Debug.Assert(check, testOrbitDefinition + " calculated position isn't same in 0 and 5*T");
check = Debug.Equals(orbitIn0, orbitIn10T);
Debug.Assert(check, testOrbitDefinition + " calculated position isn't same in 0 and 10*T");
}
/// <summary>
/// Metoda pro vytvoreni elementu z trajektorie
/// </summary>
/// <param name="trajectory">Trajektorie pro zpracovani</param>
/// <returns>Element s trajektorii</returns>
private static XElement TrajectoryToElement(Trajectory trajectory)
{
XElement trajectoryElement = new XElement("trajectory");
XElement trajectoryShapeElement = null;
if (trajectory is CircularOrbit)
{
CircularOrbit circOrbit = (CircularOrbit)trajectory;
trajectoryShapeElement = new XElement("circularOrbit");
trajectoryShapeElement.Add(new XAttribute("direction", circOrbit.Direction.ToString().ToLower()));
trajectoryShapeElement.Add(new XAttribute("period", circOrbit.PeriodInSec));
String initialAngle = Math.Round(MathUtil.RadianToDegree(circOrbit.InitialAngleRad)).ToString("0.0", CultureInfo.InvariantCulture);
trajectoryShapeElement.Add(new XAttribute("initialAngle", initialAngle));
trajectoryShapeElement.Add(new XAttribute("radius", circOrbit.Radius));
}
else if (trajectory is EllipticOrbit)
{
EllipticOrbit elliOrbit = (EllipticOrbit)trajectory;
trajectoryShapeElement = new XElement("ellipticOrbit");
trajectoryShapeElement.Add(new XAttribute("direction", elliOrbit.Direction.ToString().ToLower()));
trajectoryShapeElement.Add(new XAttribute("period", elliOrbit.PeriodInSec));
trajectoryShapeElement.Add(new XAttribute("a", elliOrbit.A));
trajectoryShapeElement.Add(new XAttribute("b", elliOrbit.B));
String angle = Math.Round(MathUtil.RadianToDegree(elliOrbit.RotationAngleInRad)).ToString("0.0", CultureInfo.InvariantCulture);
trajectoryShapeElement.Add(new XAttribute("angle", angle));
String initialAngle = Math.Round(MathUtil.RadianToDegree(elliOrbit.InitialAngleRad)).ToString("0.0", CultureInfo.InvariantCulture);
trajectoryShapeElement.Add(new XAttribute("initialAngle", initialAngle));
}
else if (trajectory is Stacionary)
{
Stacionary stacOrbit = (Stacionary)trajectory;
trajectoryShapeElement = new XElement("stacionary");
trajectoryShapeElement.Add(new XAttribute("x", stacOrbit.X));
trajectoryShapeElement.Add(new XAttribute("y", stacOrbit.Y));
}
trajectoryElement.Add(trajectoryShapeElement);
return(trajectoryElement);
}
/// <summary>
/// Metoda vracejici grafiku pro vykresleni
/// </summary>
/// <returns>Grafiky pro vykresleni</returns>
public override Ellipse GetShape()
{
Brush brush = Brushes.White;
Ellipse ellipse = new Ellipse();
double a = 0;
double b = 0;
double rotationAngle = 0;
double xPos = Editor.dataPresenter.DrawingAreaSize;
double yPos = Editor.dataPresenter.DrawingAreaSize;
if (Trajectory is CircularOrbit)
{
CircularOrbit orbit = (CircularOrbit)Trajectory;
a = orbit.Radius * Editor.dataPresenter.ObjectSizeRatio;
b = a;
//Point2d point = orbit.CalculatePosition(0);
xPos -= a;
yPos -= b;
ellipse.Width = 2 * a;
ellipse.Height = 2 * b;
}
else if (Trajectory is EllipticOrbit)
{
//EllipticOrbit orbit1 = this.startNavPoint.Location.Trajectory as EllipticOrbit;
EllipticOrbit orbit = (EllipticOrbit)Trajectory;
double cx = orbit.Cx * Editor.dataPresenter.ObjectSizeRatio;
double cy = orbit.Cy * Editor.dataPresenter.ObjectSizeRatio;
//setting ellipse
ellipse.Width = 2 * orbit.A * Editor.dataPresenter.ObjectSizeRatio;
ellipse.Height = 2 * orbit.B * Editor.dataPresenter.ObjectSizeRatio;
//transformation prepare
TransformGroup transformations = new TransformGroup();
//translation
TranslateTransform translate = new TranslateTransform(cx, cy);
transformations.Children.Add(translate);
//rotation
rotationAngle = MathUtil.RadianToDegree(orbit.RotationAngleInRad);
RotateTransform rotateTransform = new RotateTransform(-rotationAngle);
rotateTransform.CenterX = (orbit.A - orbit.OrbitalEccentricity) * Editor.dataPresenter.ObjectSizeRatio;
rotateTransform.CenterY = (orbit.B) * Editor.dataPresenter.ObjectSizeRatio;
transformations.Children.Add(rotateTransform);
//finishing transformation
ellipse.RenderTransform = transformations;
brush = Brushes.Wheat;
//setting drawing position
xPos -= orbit.A * Editor.dataPresenter.ObjectSizeRatio;
yPos -= orbit.B * Editor.dataPresenter.ObjectSizeRatio;
#region junk
//gr.RotateTransform((float)MathUtil.RadianToDegree(orbit.RotationAngleInRad));
//gr.TranslateTransform(cx, 0); //vycentrování elipsy
//this.DrawEllipse(gr, orbitPen, 0, 0, orbit.A, orbit.B);
//gr.TranslateTransform(-cx, 0); //vrácení zpět
//gr.RotateTransform(-(float)MathUtil.RadianToDegree(orbit.RotationAngleInRad));
//a = orbit.Cx;
//b = orbit.Cy;
#endregion
}
else
{
throw new ArgumentException("Invalid trajectory");
}
//a = (int)(a * Editor.dataPresenter.ObjectSizeRatio);
//b = (int)(b * Editor.dataPresenter.ObjectSizeRatio);
//a,b = semi-axis
//placement logic
//Editor.Log("size: " + Editor.dataPresenter.DrawingAreaSize + ", a:" + a);
//Editor.Log("Trajectory: " + xPos + ":" + yPos);
ellipse.Stroke = brush;
ellipse.StrokeThickness = 1;
Point2d drawingPoint = new Point2d(xPos, yPos);
this.Position = drawingPoint;
return(ellipse);
}
