/// <summary>
/// Converts a <see cref="JulianDate"/> to an ISO8601 date string.
/// </summary>
/// <param name="date">The date to convert.</param>
/// <param name="format">The format to use.</param>
/// <returns>The date represented as an ISO8601 date string.</returns>
public static string ToIso8601(JulianDate date, Iso8601Format format)
{
//If the JulianDate is outside the range of supported CZML values,
//clamp it to the minimum/maximum CZML ISO8601 value.
if (date <= s_minimumGregorianDate)
{
switch (format)
{
case Iso8601Format.Basic:
return "00000101T000000Z";
case Iso8601Format.Compact:
return "00000101T00Z";
case Iso8601Format.Extended:
return "0000-01-01T00:00:00Z";
}
}
if (date >= s_maximumGregorianDate)
{
switch (format)
{
case Iso8601Format.Basic:
return "99991231T240000Z";
case Iso8601Format.Compact:
return "99991231T24Z";
case Iso8601Format.Extended:
return "9999-12-31T24:00:00Z";
}
}
return date.ToGregorianDate().ToIso8601String(format);
}
private static TimeInterval GetTimeSpan(XElement timespan, XNamespace docNamespace)
{
XElement beginElement = timespan.Element(docNamespace + "begin");
JulianDate begin = new JulianDate(GregorianDate.MinValue);
JulianDate end = new JulianDate(GregorianDate.MaxValue);
if (beginElement != null)
{
GregorianDate beginDate;
if (!GregorianDate.TryParse(beginElement.Value, out beginDate))
{
beginDate = GregorianDate.ParseExact(beginElement.Value, ValidIso8601Formats, CultureInfo.CurrentCulture);
}
begin = new JulianDate(beginDate);
}
XElement endElement = timespan.Element(docNamespace + "end");
if (endElement != null)
{
GregorianDate endDate;
if (!GregorianDate.TryParse(endElement.Value, out endDate))
{
endDate = GregorianDate.ParseExact(endElement.Value, ValidIso8601Formats, CultureInfo.CurrentCulture);
}
end = new JulianDate(endDate);
}
return(new TimeInterval(begin, end));
}
public void AvailabilityValueWritesAvailabilityProperty()
{
JulianDate start = new JulianDate(new GregorianDate(2012, 4, 2, 1, 2, 3));
JulianDate stop = new JulianDate(new GregorianDate(2012, 4, 3, 1, 2, 3));
m_output.WriteStartSequence();
using (PacketCesiumWriter packet = m_writer.OpenPacket(m_output))
{
packet.WriteAvailability(start, stop);
}
using (PacketCesiumWriter packet = m_writer.OpenPacket(m_output))
{
packet.WriteAvailability(new TimeInterval(start, stop));
}
using (PacketCesiumWriter packet = m_writer.OpenPacket(m_output))
{
var intervals = new List<TimeInterval>();
intervals.Add(new TimeInterval(start, stop));
intervals.Add(new TimeInterval(start.AddDays(2.0), stop.AddDays(2.0)));
packet.WriteAvailability(intervals);
}
m_output.WriteEndSequence();
Assert.AreEqual("[{\"availability\":\"20120402T010203Z/20120403T010203Z\"}," +
"{\"availability\":\"20120402T010203Z/20120403T010203Z\"}," +
"{\"availability\":[\"20120402T010203Z/20120403T010203Z\",\"20120404T010203Z/20120405T010203Z\"]}]",
m_sw.ToString());
}
/// <summary>
/// Writes the time-tagged <see cref="UnitQuaternion"/> collection as an array in
/// [Time, X, Y, Z, W] 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 WriteUnitQuaternion(CesiumOutputStream output, string propertyName, IList <JulianDate> dates, IList <UnitQuaternion> 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]));
UnitQuaternion quaternion = values[i];
output.WriteValue(quaternion.X);
output.WriteValue(quaternion.Y);
output.WriteValue(quaternion.Z);
output.WriteValue(quaternion.W);
output.WriteLineBreak();
}
output.WriteEndSequence();
}
public void JulianToGregorianDate()
{
JulianDate julianDate = new JulianDate(2451545.0, TimeStandard.CoordinatedUniversalTime);
GregorianDate gregorianDate = julianDate.ToGregorianDate();
Assert.AreEqual(2000, gregorianDate.Year);
Assert.AreEqual(1, gregorianDate.Month);
Assert.AreEqual(1, gregorianDate.Day);
Assert.AreEqual(12, gregorianDate.Hour);
Assert.AreEqual(0, gregorianDate.Minute);
Assert.AreEqual(0, gregorianDate.Second);
julianDate = new JulianDate(2453736.5, TimeStandard.CoordinatedUniversalTime);
gregorianDate = julianDate.ToGregorianDate();
Assert.AreEqual(2006, gregorianDate.Year);
Assert.AreEqual(1, gregorianDate.Month);
Assert.AreEqual(1, gregorianDate.Day);
Assert.AreEqual(0, gregorianDate.Hour);
Assert.AreEqual(0, gregorianDate.Minute);
Assert.AreEqual(0, gregorianDate.Second);
julianDate = new JulianDate(2441683.5, TimeStandard.CoordinatedUniversalTime);
gregorianDate = julianDate.ToGregorianDate();
Assert.AreEqual(1973, gregorianDate.Year);
Assert.AreEqual(1, gregorianDate.Month);
Assert.AreEqual(1, gregorianDate.Day);
Assert.AreEqual(0, gregorianDate.Hour);
Assert.AreEqual(0, gregorianDate.Minute);
Assert.AreEqual(0, gregorianDate.Second);
julianDate = new JulianDate(2441683.5, TimeStandard.CoordinatedUniversalTime);
GregorianDate internationalTimeGregorianDate = julianDate.ToGregorianDate(TimeStandard.InternationalAtomicTime);
Assert.AreNotEqual(gregorianDate, internationalTimeGregorianDate);
}
/// <summary>
/// Writes time-tagged <see cref="Cartographic"/> values as an array in [Time, Longitude, Latitude, Height] 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 WriteCartographic(CesiumOutputStream output, string propertyName, IList <JulianDate> dates, IList <Cartographic> 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]));
Cartographic value = values[i];
output.WriteValue(value.Longitude);
output.WriteValue(value.Latitude);
output.WriteValue(value.Height);
output.WriteLineBreak();
}
output.WriteEndSequence();
}
/// <summary>
/// Writes time-tagged <see cref="Motion<Cartesian>"/> values as an array in [Time, X, Y, Z, vX, vY, vZ] 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 WriteCartesian3Velocity(CesiumOutputStream output, string propertyName, IList <JulianDate> dates, IList <Motion <Cartesian> > 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]));
Cartesian value = values[i].Value;
Cartesian velocity = values[i].FirstDerivative;
output.WriteValue(value.X);
output.WriteValue(value.Y);
output.WriteValue(value.Z);
output.WriteValue(velocity.X);
output.WriteValue(velocity.Y);
output.WriteValue(velocity.Z);
output.WriteLineBreak();
}
output.WriteEndSequence();
}
public void TestParseISO8601DayOfYear()
{
GregorianDate iso = new GregorianDate(1985, 2, 11, 2, 0, 5.2134);
GregorianDate result = GregorianDate.Parse("1985-042T02:00:05.2134");
Assert.AreEqual(iso, result);
iso = new GregorianDate(1985, 2, 11, 2, 0, 5.21345);
result = GregorianDate.Parse("1985-042T02:00:05.21345Z");
Assert.AreEqual(iso, result);
iso = new GregorianDate(1985, 2, 11, 2, 0, 5);
result = GregorianDate.Parse("1985-042T02:00:05");
Assert.AreEqual(iso, result);
iso = new GregorianDate(1985, 2, 11);
result = GregorianDate.Parse("1985-042");
Assert.AreEqual(iso, result);
// Make sure to check each month to ensure we have it right
string first = "1986-";
string last = "T02:01:04Z";
JulianDate baseDate = new JulianDate(new GregorianDate(1986, 1, 12, 02, 01, 4));
for (int i = 1; i < 12; i++)
{
string testString = string.Format(first + "{0:000}" + last, 12 + i * 30);
GregorianDate expected = baseDate.AddDays(i * 30).ToGregorianDate();
Assert.AreEqual(expected, GregorianDate.Parse(testString));
}
}
public void CartesianValueSubsetWritesMultipleCartesianProperty()
{
JulianDate startDate = new JulianDate(new GregorianDate(2012, 4, 2, 12, 0, 0));
using (Packet)
using (PositionCesiumWriter position = Packet.OpenPositionProperty())
using (PositionCesiumWriter interval = position.OpenInterval())
{
var dates = new List <JulianDate>();
var positions = new List <Cartesian>();
dates.Add(startDate);
positions.Add(new Cartesian(1.0, 2.0, 3.0));
dates.Add(startDate.AddSeconds(60.0));
positions.Add(new Cartesian(4.0, 5.0, 6.0));
dates.Add(startDate.AddSeconds(120.0));
positions.Add(new Cartesian(7.0, 8.0, 9.0));
interval.WriteCartesian(dates, positions, 1, 1);
}
Assert.AreEqual("{\"position\":{\"epoch\":\"20120402T1201Z\",\"cartesian\":[0,4,5,6]}}", StringWriter.ToString());
}
public void CreateExampleFile()
{
using (var stringWriter = new StringWriter())
{
var output = new CesiumOutputStream(stringWriter)
{
PrettyFormatting = true
};
var writer = new CesiumStreamWriter();
using (var packet = writer.OpenPacket(output))
{
packet.WriteId("MyID");
var startDate = new JulianDate(new GregorianDate(2012, 4, 2, 12, 0, 0));
var stopDate = new JulianDate(new GregorianDate(2012, 4, 2, 12, 1, 0));
using (var clockWriter = packet.OpenClockProperty())
{
using (var intervalClockWriter = clockWriter.OpenInterval(startDate, stopDate))
{
intervalClockWriter.WriteCurrentTime(startDate);
}
}
using (var modelWriter = packet.OpenModelProperty())
{
modelWriter.WriteGltfProperty(new Uri("example.gltf", UriKind.Relative), CesiumResourceBehavior.LinkTo);
using (var nodeTransformationsWriter = modelWriter.OpenNodeTransformationsProperty())
{
using (var nodeTransformationWriter = nodeTransformationsWriter.OpenNodeTransformationProperty("node1"))
{
nodeTransformationWriter.WriteScaleProperty(new Cartesian(1.0, 2.0, 3.0));
nodeTransformationWriter.WriteRotationProperty(UnitQuaternion.Identity);
nodeTransformationWriter.WriteTranslationProperty(new Cartesian(4.0, 5.0, 6.0));
}
using (var nodeTransformationWriter = nodeTransformationsWriter.OpenNodeTransformationProperty("node2"))
{
var dates = new List <JulianDate>
{
startDate,
stopDate
};
var values = new List <Cartesian>
{
new Cartesian(1.0, 2.0, 3.0),
new Cartesian(10.0, 12.0, 14.0)
};
nodeTransformationWriter.WriteScaleProperty(dates, values);
}
}
}
}
Console.WriteLine(stringWriter.ToString());
}
}
public void Add(MotionEvaluator <Cartesian> evaluator, JulianDate epoch)
{
Cartesian position = evaluator.Evaluate(epoch);
m_noAccessPositions.Add(position);
m_satellites.Add(evaluator);
}
public DaoSearchParameter(DbSelectParameter selectParameter, Comparison whereOperator)
: this()
{
Comparison = whereOperator;
SelectParameter = selectParameter;
this.dateValue = selectParameter.Value is DateTime ? selectParameter.Value: null;
this.julianValue = selectParameter.Value is DateTime ? (object)JulianDate.ToJulianDate((DateTime)this.dateValue) : null;
}
public void TestCalculateDuration()
{
JulianDate start = new JulianDate(2451545.0);
JulianDate stop = start + Duration.FromDays(1.5);
TimeInterval interval = new TimeInterval(start, stop);
Assert.AreEqual(Duration.FromDays(1.5), interval.ToDuration());
}
public void TestEqualityOfLeapSeconds()
{
JulianDate leapSecond = new JulianDate(2453736, 43233, TimeStandard.InternationalAtomicTime);
JulianDate utcDate = new JulianDate(2453736, 43233, TimeStandard.CoordinatedUniversalTime);
Assert.IsFalse(utcDate.Equals(leapSecond));
Assert.IsFalse(leapSecond.Equals(utcDate));
}
public void TestRetainValue()
{
JulianDate start = new JulianDate(DateTime.UtcNow);
JulianDate stop = start + Duration.FromDays(1.5);
TimeInterval interval = new TimeInterval(start, stop);
Assert.AreEqual(start, interval.Start);
Assert.AreEqual(stop, interval.Stop);
}
public void TestToString()
{
JulianDate date = new JulianDate(2451545.5);
string expected = string.Format("2451545:43200 TAI ({0})", date.ToGregorianDate());
Assert.AreEqual(expected, date.ToString());
}
public void TestCompareToObject()
{
JulianDate date1 = new JulianDate(2451545.0);
object date2 = new JulianDate(2451545.0);
Assert.Greater(date1.CompareTo(null), 0);
Assert.AreEqual(0, date1.CompareTo(date2));
}
public void TestCalculateDuration()
{
JulianDate start = new JulianDate(2451545.0);
JulianDate stop = start + Duration.FromDays(1.5);
TimeInterval interval = new TimeInterval(start, stop);
Assert.AreEqual(Duration.FromDays(1.5), interval.ToDuration());
}
public void TestCompareToObject()
{
JulianDate date1 = new JulianDate(2451545.0);
object date2 = new JulianDate(2451545.0);
Assert.IsTrue(date1.CompareTo(null) > 0);
Assert.IsTrue(date1.CompareTo(date2) == 0);
}
/// <summary>
/// Propagate a Platform using a NumericalPropagator configured with the entered KeplerianElements,
/// ForceModels, NumericalIntegrator, and start and stop dates.
/// </summary>
private void PropagateSatellite()
{
KeplerianElements orbitalElements = m_keplerianOrbitalElementsEntry.KeplerianElementValues;
if (orbitalElements == null)
{
return;
}
Motion <Cartesian> initialMotion = orbitalElements.ToCartesian();
PropagationNewtonianPoint point = new PropagationNewtonianPoint(m_elementID, m_forceModelSettings.CurrentCentralBody.InertialFrame, initialMotion.Value, initialMotion.FirstDerivative);
point.Mass = new ScalarFixed(double.Parse(m_mass.Text));
m_forceModelSettings.SetForceModelsOnPoint(point, new ScalarFixed(double.Parse(m_area.Text)));
CentralBody primaryCentralBody = m_forceModelSettings.CurrentCentralBody;
NumericalPropagatorDefinition state = new NumericalPropagatorDefinition();
state.IntegrationElements.Add(point);
state.Integrator = m_integratorSettings.GetIntegrator();
JulianDate start = new JulianDate(GregorianDate.ParseExact(m_start.Text, DateFormat, null));
JulianDate end = new JulianDate(GregorianDate.ParseExact(m_end.Text, DateFormat, null));
state.Epoch = start;
NumericalPropagator propagator = state.CreatePropagator();
propagator.StepTaken += (sender, args) =>
{
// Telling the propagator to stop if we get too close to the central body
Cartesian position = propagator.Converter.ConvertState <Cartesian>(m_elementID, args.CurrentState).Value;
if (position.Magnitude <= primaryCentralBody.Shape.SemimajorAxisLength + 10000)
{
args.Indication = PropagationEventIndication.StopPropagationAfterStep;
}
};
DateMotionCollection <Cartesian> answer = null;
var backgroundCalculation = new BackgroundCalculation();
backgroundCalculation.DoWork += (sender, e) =>
{
// actually propagate
var result = propagator.Propagate(end.Subtract(start), 1, backgroundCalculation);
answer = result.GetDateMotionCollection <Cartesian>(m_elementID);
};
backgroundCalculation.ProgressChanged += (sender, e) => m_propagationProgress.Value = e.ProgressPercentage;
backgroundCalculation.RunWorkerCompleted += (sender, e) =>
{
// when finished, draw the satellite
DrawSatellite(answer, primaryCentralBody.InertialFrame);
m_propagate.Enabled = true;
};
m_propagate.Enabled = false;
backgroundCalculation.RunWorkerAsync();
}
public void TestJulianDateMinimumToDateTime()
{
JulianDate date = JulianDate.MinValue;
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
DateTime unused = date.ToDateTime();
});
}
public void CreateExampleFile()
{
using (var stringWriter = new StringWriter())
{
var output = new CesiumOutputStream(stringWriter)
{
PrettyFormatting = true
};
var writer = new CesiumStreamWriter();
using (var packet = writer.OpenPacket(output))
{
packet.WriteId("MyID");
var startDate = new JulianDate(new GregorianDate(2012, 4, 2, 12, 0, 0));
var stopDate = new JulianDate(new GregorianDate(2012, 4, 2, 12, 1, 0));
using (var clockWriter = packet.OpenClockProperty())
{
using (var intervalClockWriter = clockWriter.OpenInterval(startDate, stopDate))
{
intervalClockWriter.WriteCurrentTime(startDate);
}
}
using (var modelWriter = packet.OpenModelProperty())
{
modelWriter.WriteGltfProperty(new Uri("example.gltf", UriKind.Relative), CesiumResourceBehavior.LinkTo);
using (var articulationsWriter = modelWriter.OpenArticulationsProperty())
{
using (var articulationWriter = articulationsWriter.OpenArticulationProperty("articulation1 stage1"))
{
articulationWriter.WriteNumber(45);
}
using (var articulationWriter = articulationsWriter.OpenArticulationProperty("articulation1 stage2"))
{
var dates = new List <JulianDate>
{
startDate,
stopDate
};
var values = new List <double>
{
1.0,
10.0
};
articulationWriter.WriteNumber(dates, values);
}
}
}
}
Console.WriteLine(stringWriter.ToString());
}
}
public void MaxValueRoundTripsThroughJulianDate()
{
JulianDate max = GregorianDate.MaxValue.ToJulianDate();
GregorianDate date = max.ToGregorianDate();
string iso = date.ToIso8601String(Iso8601Format.Extended, 6);
string expected = GregorianDate.MaxValue.ToIso8601String(Iso8601Format.Extended, 6);
Assert.AreEqual(expected, iso);
}
public void TestLeapSecondCount()
{
LeapSeconds leapSeconds = new LeapSeconds();
JulianDate utc = new GregorianDate(1998, 4, 1, 12, 0, 0).ToJulianDate();
JulianDate tai = utc.ToTimeStandard(TimeStandard.InternationalAtomicTime);
Assert.AreEqual(31, leapSeconds.GetTaiMinusUtc(utc));
Assert.AreEqual(31, leapSeconds.GetTaiMinusUtc(tai));
}
public void TestCompareToWrongType()
{
JulianDate date = new JulianDate(2451545.0);
Assert.Throws <ArgumentException>(() =>
{
int unused = date.CompareTo(2451545.0);
});
}
private void OnTimeChanged(object sender, TimeChangedEventArgs e)
{
if (m_temeToFixedEvaluator == null)
{
return;
}
JulianDate date = e.Time;
Matrix3By3 temeToFixed = new Matrix3By3(m_temeToFixedEvaluator.Evaluate(date));
KinematicTransformation transformation = m_fixedToFacilityTopoEvaluator.Evaluate(date, 0);
List <int> satellitesToRemove = null;
m_satellites.ClearPositions();
for (int i = 0; i < m_satellites.Count; ++i)
{
MotionEvaluator <Cartesian> satellite = m_satellites.GetSatellite(i);
try
{
// Update position of marker representing this satellite
Cartesian position = satellite.Evaluate(date).Rotate(temeToFixed);
// Compute access from satellite to facility
if (m_showAccess)
{
Cartesian positionInTopo = transformation.Transform(position);
AzimuthElevationRange azimuthElevationRange = new AzimuthElevationRange(positionInTopo);
m_satellites.AppendPosition(position, azimuthElevationRange.Elevation > 0.0);
}
else
{
m_satellites.AppendPosition(position, false);
}
}
catch (Exception)
{
if (satellitesToRemove == null)
{
satellitesToRemove = new List <int>();
}
satellitesToRemove.Add(i);
}
}
// Remove satellites that could not be evaluated
if (satellitesToRemove != null)
{
m_satellites.RemoveUsingIndexList(satellitesToRemove);
SetText(m_satellites.Count);
}
m_satellites.SetMarkerBatches();
}
public void TestJulianDateCannotRepresentMomentOfLeapSecond()
{
JulianDate momentOfLeapSecond = new JulianDate(2453736, 43232.0, TimeStandard.InternationalAtomicTime);
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
var unused = momentOfLeapSecond.ToTimeStandard(TimeStandard.CoordinatedUniversalTime);
});
}
public void TestJulianDateNow()
{
JulianDate first = JulianDate.Now;
Thread.Sleep(100);
JulianDate second = JulianDate.Now;
Assert.Greater(second, first);
}
public void TestRetainValue()
{
JulianDate start = new JulianDate(DateTime.UtcNow);
JulianDate stop = start + Duration.FromDays(1.5);
TimeInterval interval = new TimeInterval(start, stop);
Assert.AreEqual(start, interval.Start);
Assert.AreEqual(stop, interval.Stop);
}
public void TestLeapSecondCount()
{
LeapSeconds leapSeconds = new LeapSeconds();
JulianDate utc = new JulianDate(new GregorianDate(1998, 4, 1, 12, 0, 0));
JulianDate tai = utc.ToTimeStandard(TimeStandard.InternationalAtomicTime);
Assert.AreEqual(31, leapSeconds.GetTaiMinusUtc(utc));
Assert.AreEqual(31, leapSeconds.GetTaiMinusUtc(tai));
}
public void TestTimeExactlyOneDay()
{
JulianDate date = new JulianDate(2451545, 86400.0);
Assert.AreEqual(2451546, date.Day);
Assert.AreEqual(0.0, date.SecondsOfDay);
date = new JulianDate(2451545, 86400.0, TimeStandard.InternationalAtomicTime);
Assert.AreEqual(2451546, date.Day);
Assert.AreEqual(0.0, date.SecondsOfDay);
}
public void TestSubtractSeconds()
{
// Make sure SubtractSeconds produces the correct answer in the correct time standard.
JulianDate test = new JulianDate(2451912, 0.0, TimeStandard.InternationalAtomicTime);
JulianDate result = test.SubtractSeconds(43200.25);
Assert.AreEqual(TimeStandard.InternationalAtomicTime, result.Standard);
Assert.AreEqual(2451911, result.Day);
Assert.AreEqual(43199.75, result.SecondsOfDay);
}
public void TestTimeGreaterThanADay()
{
JulianDate date = new JulianDate(2451545, 107000.0);
Assert.AreEqual(2451546, date.Day);
Assert.AreEqual(20600.0, date.SecondsOfDay);
date = new JulianDate(2451545, 107000.0, TimeStandard.InternationalAtomicTime);
Assert.AreEqual(2451546, date.Day);
Assert.AreEqual(20600.0, date.SecondsOfDay);
}
public void TestAddDays()
{
// Make sure AddDays produces the correct answer in the correct time standard.
JulianDate test = new JulianDate(2451912, 43200.0, TimeStandard.InternationalAtomicTime);
JulianDate result = test.AddDays(45.5);
Assert.AreEqual(TimeStandard.InternationalAtomicTime, result.Standard);
Assert.AreEqual(2451958, result.Day);
Assert.AreEqual(0.0, result.SecondsOfDay);
}
public void TestTimeNegative()
{
JulianDate date = new JulianDate(2451545, -45000.0);
Assert.AreEqual(2451544, date.Day);
Assert.AreEqual(41400.0, date.SecondsOfDay);
date = new JulianDate(2451545, -45000.0, TimeStandard.InternationalAtomicTime);
Assert.AreEqual(2451544, date.Day);
Assert.AreEqual(41400.0, date.SecondsOfDay);
}
public void TestConvertToType()
{
JulianDate date = new JulianDate(2451545.0);
IConvertible convertible = date as IConvertible;
DateTimeFormatInfo info = new DateTimeFormatInfo();
Assert.AreEqual(date.ToString(), convertible.ToType(typeof(string), info));
Assert.AreEqual(date.ToDateTime(), convertible.ToType(typeof(DateTime), info));
Assert.AreEqual(date.TotalDays, convertible.ToType(typeof(double), info));
}
public void AddSecond()
{
JulianDate jd = new JulianDate(new DateTime(2003, 1, 1));
JulianDate jd1 = new JulianDate(jd);
jd1.AddSeconds(24);
Assert.That(jd1 - jd, Is.EqualTo(24.0 / (3600 * 24)).Within(0.00000000000001));
DateTime dt = jd1.ToDateTime();
Assert.That(dt.Second, Is.EqualTo(24));
}
public void TestTimeExactlyOneDay()
{
JulianDate date = new JulianDate(2451545, TimeConstants.SecondsPerDay);
Assert.AreEqual(2451546, date.Day);
Assert.AreEqual(0.0, date.SecondsOfDay);
date = new JulianDate(2451545, TimeConstants.SecondsPerDay, TimeStandard.InternationalAtomicTime);
Assert.AreEqual(2451546, date.Day);
Assert.AreEqual(0.0, date.SecondsOfDay);
}
public void TestTimeNegative()
{
JulianDate date = new JulianDate(2451545, -45000.0);
Assert.AreEqual(2451544, date.Day);
Assert.AreEqual(41400.0, date.SecondsOfDay);
date = new JulianDate(2451545, -45000.0, TimeStandard.InternationalAtomicTime);
Assert.AreEqual(2451544, date.Day);
Assert.AreEqual(41400.0, date.SecondsOfDay);
}
public void TestTimeGreaterThanADay()
{
JulianDate date = new JulianDate(2451545, 107000.0);
Assert.AreEqual(2451546, date.Day);
Assert.AreEqual(20600.0, date.SecondsOfDay);
date = new JulianDate(2451545, 107000.0, TimeStandard.InternationalAtomicTime);
Assert.AreEqual(2451546, date.Day);
Assert.AreEqual(20600.0, date.SecondsOfDay);
}
public void TestTimeStandard()
{
JulianDate date = new JulianDate(0);
Assert.AreEqual(TimeStandard.InternationalAtomicTime, date.Standard);
date = new JulianDate(100, 123.456789012);
Assert.AreEqual(TimeStandard.InternationalAtomicTime, date.Standard);
date = new JulianDate(100, 123.456789012, TimeStandard.CoordinatedUniversalTime);
Assert.AreEqual(TimeStandard.CoordinatedUniversalTime, date.Standard);
}
public void TestGetLeapSecondsForDateTaiUtc()
{
LeapSeconds leapSeconds = new LeapSeconds();
JulianDate tai = new JulianDate(2447162.5, TimeStandard.InternationalAtomicTime);
JulianDate utc = tai.ToTimeStandard(TimeStandard.CoordinatedUniversalTime);
Assert.AreEqual(leapSeconds.GetTaiMinusUtc(tai), leapSeconds.GetTaiMinusUtc(utc));
utc = new JulianDate(2445151.5, TimeStandard.CoordinatedUniversalTime);
tai = utc.ToTimeStandard(TimeStandard.InternationalAtomicTime);
Assert.AreEqual(leapSeconds.GetTaiMinusUtc(utc), leapSeconds.GetTaiMinusUtc(tai));
}
public void TestExtremes()
{
LeapSeconds leapSeconds = new LeapSeconds();
JulianDate epochBefore = new JulianDate(2440000.5, TimeStandard.InternationalAtomicTime);
Assert.AreEqual(10, leapSeconds.GetTaiMinusUtc(epochBefore));
epochBefore = new JulianDate(epochBefore.Day, epochBefore.SecondsOfDay, TimeStandard.CoordinatedUniversalTime);
Assert.AreEqual(10, leapSeconds.GetTaiMinusUtc(epochBefore));
JulianDate epochAfter = new JulianDate(2453770.5, TimeStandard.InternationalAtomicTime);
Assert.AreEqual(33, leapSeconds.GetTaiMinusUtc(epochAfter));
epochAfter = new JulianDate(epochAfter.Day, epochAfter.SecondsOfDay, TimeStandard.CoordinatedUniversalTime);
Assert.AreEqual(33, leapSeconds.GetTaiMinusUtc(epochAfter));
}
public void JulianToDateTime()
{
JulianDate julianDate = new JulianDate(2451545.0, TimeStandard.CoordinatedUniversalTime);
DateTime dateTime = julianDate.ToDateTime();
Assert.AreEqual(2000, dateTime.Year);
Assert.AreEqual(1, dateTime.Month);
Assert.AreEqual(1, dateTime.Day);
Assert.AreEqual(12, dateTime.Hour);
Assert.AreEqual(0, dateTime.Minute);
Assert.AreEqual(0, dateTime.Second);
Assert.AreEqual(0, dateTime.Millisecond);
Assert.AreEqual(DateTimeKind.Utc, dateTime.Kind);
julianDate = new JulianDate(2453736.5, TimeStandard.CoordinatedUniversalTime);
dateTime = julianDate.ToDateTime();
Assert.AreEqual(2006, dateTime.Year);
Assert.AreEqual(1, dateTime.Month);
Assert.AreEqual(1, dateTime.Day);
Assert.AreEqual(0, dateTime.Hour);
Assert.AreEqual(0, dateTime.Minute);
Assert.AreEqual(0, dateTime.Second);
Assert.AreEqual(0, dateTime.Millisecond);
Assert.AreEqual(DateTimeKind.Utc, dateTime.Kind);
julianDate = new JulianDate(2441683.5, TimeStandard.CoordinatedUniversalTime);
dateTime = julianDate.ToDateTime();
Assert.AreEqual(1973, dateTime.Year);
Assert.AreEqual(1, dateTime.Month);
Assert.AreEqual(1, dateTime.Day);
Assert.AreEqual(0, dateTime.Hour);
Assert.AreEqual(0, dateTime.Minute);
Assert.AreEqual(0, dateTime.Second);
Assert.AreEqual(0, dateTime.Millisecond);
Assert.AreEqual(DateTimeKind.Utc, dateTime.Kind);
julianDate = new JulianDate(2441683.5, TimeStandard.InternationalAtomicTime);
dateTime = julianDate.ToDateTime(TimeStandard.InternationalAtomicTime);
Assert.AreEqual(DateTimeKind.Utc, dateTime.Kind);
julianDate = new JulianDate(2441683.5, TimeStandard.InternationalAtomicTime);
dateTime = julianDate.ToDateTime(TimeStandard.CoordinatedUniversalTime);
Assert.AreEqual(DateTimeKind.Utc, dateTime.Kind);
}
public void TestGetOffsetTai()
{
JulianDate date = new JulianDate(2453736, 43222.0, TimeStandard.InternationalAtomicTime);
LeapSeconds leapSeconds = new LeapSeconds();
Assert.AreEqual(32, leapSeconds.GetTaiMinusUtc(date));
}
public void TestJulianDateCannotRepresentMomentOfLeapSecond()
{
JulianDate momentOfLeapSecond = new JulianDate(2453736, 43232.0, TimeStandard.InternationalAtomicTime);
momentOfLeapSecond.ToTimeStandard(TimeStandard.CoordinatedUniversalTime);
}
public void TestTaiToUtcNearLeapSecond()
{
LeapSeconds leapSeconds = new LeapSeconds();
LeapSeconds.Instance = leapSeconds;
JulianDate momentOfLeapSecond = new JulianDate(2453736, 43232.0, TimeStandard.InternationalAtomicTime);
JulianDate before = momentOfLeapSecond - Duration.FromSeconds(1.0);
JulianDate after = momentOfLeapSecond + Duration.FromSeconds(1.0);
JulianDate beforeUtc = before.ToTimeStandard(TimeStandard.CoordinatedUniversalTime);
JulianDate afterUtc = after.ToTimeStandard(TimeStandard.CoordinatedUniversalTime);
Assert.AreNotEqual(beforeUtc, afterUtc);
}
public void JulianDateTimeRoundTrip()
{
DateTime dateTime = DateTime.UtcNow;
JulianDate julianDate = new JulianDate(dateTime);
DateTime roundTrip = julianDate.ToDateTime();
Assert.AreEqual(dateTime.Year, roundTrip.Year);
Assert.AreEqual(dateTime.Month, roundTrip.Month);
Assert.AreEqual(dateTime.Day, roundTrip.Day);
Assert.AreEqual(dateTime.Hour, roundTrip.Hour);
Assert.AreEqual(dateTime.Minute, roundTrip.Minute);
Assert.AreEqual(dateTime.Second, roundTrip.Second);
Assert.AreEqual(dateTime.Millisecond, roundTrip.Millisecond);
}
/// <summary>
/// Writes a <see cref="JulianDate"/> as an ISO 8601 interval string.
/// </summary>
/// <param name="output">The stream to which to write the value.</param>
/// <param name="date">The date to write.</param>
public static void WriteDate(CesiumOutputStream output, JulianDate date)
{
output.WriteValue(CesiumFormattingHelper.ToIso8601(date, output.PrettyFormatting ? Iso8601Format.Extended : Iso8601Format.Compact));
}
private TimeInterval GetTimeSpan(XElement timespan)
{
XElement beginElement = timespan.Element(Document.Namespace + "begin");
JulianDate begin =new JulianDate(GregorianDate.MinValue);
JulianDate end = new JulianDate(GregorianDate.MaxValue);
if (beginElement != null)
{
GregorianDate beginDate;
if (!GregorianDate.TryParse(beginElement.Value, out beginDate))
{
beginDate = GregorianDate.ParseExact(beginElement.Value, s_validIso8601Formats, CultureInfo.CurrentCulture);
}
begin = new JulianDate(beginDate);
}
XElement endElement = timespan.Element(Document.Namespace + "end");
if (endElement != null)
{
GregorianDate endDate;
if (!GregorianDate.TryParse(endElement.Value, out endDate))
{
endDate = GregorianDate.ParseExact(endElement.Value, s_validIso8601Formats, CultureInfo.CurrentCulture);
}
end = new JulianDate(endDate);
}
return new TimeInterval(begin, end);
}
public void GregorianDateToJulian()
{
GregorianDate gregorianDate = new GregorianDate(2000, 1, 1, 12, 0, 0);
JulianDate julianDate = new JulianDate(gregorianDate);
Assert.AreEqual(2451545.0, julianDate.TotalDays);
gregorianDate = new GregorianDate(2006, 1, 1, 0, 0, 0);
julianDate = new JulianDate(gregorianDate);
Assert.AreEqual(2453736.5, julianDate.TotalDays);
gregorianDate = new GregorianDate(1973, 1, 1, 0, 0, 0);
julianDate = new JulianDate(gregorianDate);
Assert.AreEqual(2441683.5, julianDate.TotalDays);
DateTime localDateTime = new DateTime(2000, 1, 1, 12, 0, 0, DateTimeKind.Local);
DateTime utc = localDateTime.ToUniversalTime();
julianDate = new JulianDate(localDateTime);
gregorianDate = julianDate.ToGregorianDate();
Assert.AreEqual(new GregorianDate(utc), gregorianDate);
}
public void JulianDateGregorianDateRoundTrip()
{
GregorianDate gregorianDate = new GregorianDate(2008, 1, 1, 1, 1, 1.00000000008);
JulianDate julianDate = new JulianDate(gregorianDate);
GregorianDate roundTrip = julianDate.ToGregorianDate();
Assert.AreEqual(gregorianDate.Year, roundTrip.Year);
Assert.AreEqual(gregorianDate.Month, roundTrip.Month);
Assert.AreEqual(gregorianDate.Day, roundTrip.Day);
Assert.AreEqual(gregorianDate.Hour, roundTrip.Hour);
Assert.AreEqual(gregorianDate.Minute, roundTrip.Minute);
Assert.AreEqual(gregorianDate.Second, roundTrip.Second, Constants.Epsilon13);
}
/// <summary>
/// Writes the availability interval of this object. If the <topic name="Cesium">Cesium</topic> client
/// knows an object to be available but it does not yet have that data itself, it may wait for the data to
/// arrive before allowing animation to proceed.
/// </summary>
/// <param name="startAvailability">The earliest date of availability of the object.</param>
/// <param name="endAvailability">The latest date of availability of the object.</param>
public void WriteAvailability(JulianDate startAvailability, JulianDate endAvailability)
{
WriteAvailability(new TimeInterval(startAvailability, endAvailability));
}
/// <summary>
/// Writes the <code>availability</code> property. The <code>availability</code> property specifies when data for an object is available. If data for an object is known to be available at the current animation time, but the client does not yet have that data (presumably because it will arrive in a later packet), the client will pause with a message like "Buffering..." while it waits to receive the data. The property can be a single string specifying a single interval, or an array of strings representing intervals. A later Cesium packet can update this availability if it changes or is found to be incorrect. For example, an SGP4 propagator may report availability for all time, but then later the propagator throws an exception and the availability needs to be adjusted. If this optional property is not present, the object is assumed to be available for all time. Availability is scoped to a particular CZML stream, so two different streams can list different availability for a single object. Within a single stream, the last availability stated for an object is the one in effect and any availabilities in previous packets are ignored. If an object is available at a time, the client expects the object to have at least one property, and it expects all properties that it needs to be defined at that time. If the object doesn't have any properties, or a needed property is defined but not at the animation time, the client will pause animation and wait for more data.
/// </summary>
/// <param name="start">The earliest date of the interval.</param>
/// <param name="stop">The latest date of the interval.</param>
public void WriteAvailability(JulianDate start, JulianDate stop)
{
WriteAvailability(new TimeInterval(start, stop));
}
[CSToJavaExclude] // Java DateTime only supports millisecond precision
public void TestBUG40644()
{
JulianDate jd1 = new JulianDate(2451545, 0.0, TimeStandard.CoordinatedUniversalTime);
JulianDate jd2 = new JulianDate(2451545, -0.0001, TimeStandard.CoordinatedUniversalTime);
JulianDate jd3 = new JulianDate(2451545, 0.0001, TimeStandard.CoordinatedUniversalTime);
DateTime date1 = jd1.ToDateTime();
DateTime date2 = jd2.ToDateTime();
DateTime date3 = jd3.ToDateTime();
Assert.AreNotEqual(date1, date2);
Assert.AreNotEqual(date1, date3);
Assert.AreNotEqual(date2, date3);
}
public void TestLocalDateTimeToJulian()
{
DateTime localNow = DateTime.Now;
DateTime utcNow = localNow.ToUniversalTime();
JulianDate localJD = new JulianDate(localNow);
JulianDate utcJD = new JulianDate(utcNow);
Assert.IsTrue(localJD.EqualsEpsilon(utcJD, Constants.Epsilon14));
localNow = DateTime.Now;
utcNow = localNow.ToUniversalTime();
localJD = new JulianDate(localNow, TimeStandard.InternationalAtomicTime);
utcJD = new JulianDate(utcNow, TimeStandard.InternationalAtomicTime);
Assert.IsTrue(localJD.EqualsEpsilon(utcJD, Constants.Epsilon14));
}
public void TestToTimeStandard()
{
JulianDate start = new JulianDate(2451545.0, TimeStandard.CoordinatedUniversalTime);
JulianDate stop = new JulianDate(2451546.0, TimeStandard.CoordinatedUniversalTime);
TimeInterval interval = new TimeInterval(start, stop);
TimeInterval result = interval.ToTimeStandard(TimeStandard.CoordinatedUniversalTime);
Assert.AreEqual(result.Start.Standard, TimeStandard.CoordinatedUniversalTime);
Assert.AreEqual(result.Stop.Standard, TimeStandard.CoordinatedUniversalTime);
Assert.AreEqual(result.Start.TotalDays, 2451545.0, Constants.Epsilon15);
Assert.AreEqual(result.Stop.TotalDays, 2451546.0, Constants.Epsilon15);
result = interval.ToTimeStandard(TimeStandard.InternationalAtomicTime);
Assert.AreEqual(result.Start.Standard, TimeStandard.InternationalAtomicTime);
Assert.AreEqual(result.Stop.Standard, TimeStandard.InternationalAtomicTime);
Assert.AreNotEqual(result.Start.TotalDays, 2451545.0);
Assert.AreNotEqual(result.Stop.TotalDays, 2451546.0);
TimeInterval empty = new TimeInterval(new JulianDate(2451545.0, TimeStandard.CoordinatedUniversalTime),
new JulianDate(2451545.0, TimeStandard.CoordinatedUniversalTime));
Assert.IsTrue(empty.IsEmpty);
result = empty.ToTimeStandard(TimeStandard.InternationalAtomicTime);
Assert.IsTrue(result.IsEmpty);
}
[CSToJavaExclude] // Java DateTime only supports millisecond precision
public void TestTicks()
{
DateTime yesterday = new DateTime(2008, 3, 4, 12, 5, 12, 24, DateTimeKind.Utc);
DateTime someTimeLater = new DateTime(yesterday.Ticks + 50, DateTimeKind.Utc);
JulianDate jDateYesterday = new JulianDate(yesterday);
JulianDate jDateSomeTimeLater = new JulianDate(someTimeLater);
Assert.AreNotEqual(jDateYesterday, jDateSomeTimeLater);
Assert.AreEqual(jDateYesterday.Day, jDateSomeTimeLater.Day);
Assert.AreEqual(jDateYesterday.SecondsOfDay, jDateSomeTimeLater.SecondsOfDay - 0.000005000, Constants.Epsilon9);
}
public void TestUtcAddNotStuckAtLeapSecond()
{
LeapSeconds leapSeconds = new LeapSeconds();
LeapSeconds.Instance = leapSeconds;
JulianDate date = new JulianDate(2453736, 43198.0, TimeStandard.CoordinatedUniversalTime);
JulianDate after = new JulianDate(2453736, 43202.0, TimeStandard.CoordinatedUniversalTime);
int i;
for (i = 0; i < 100; ++i)
{
date += Duration.FromSeconds(0.1);
if (date > after)
{
break;
}
}
//5 second difference, so 50 additions of a tenth of a second each
Assert.AreEqual(50, i);
}
public void DateTimeToJulian()
{
DateTime dateTime = new DateTime(2000, 1, 1, 12, 0, 0);
JulianDate julianDate = new JulianDate(dateTime);
Assert.AreEqual(2451545.0, julianDate.TotalDays);
dateTime = new DateTime(2006, 1, 1, 0, 0, 0);
julianDate = new JulianDate(dateTime);
Assert.AreEqual(2453736.5, julianDate.TotalDays);
dateTime = new DateTime(1973, 1, 1, 0, 0, 0);
julianDate = new JulianDate(dateTime);
Assert.AreEqual(2441683.5, julianDate.TotalDays);
DateTime localDateTime = new DateTime(2000, 1, 1, 12, 0, 0, DateTimeKind.Local);
DateTime utc = localDateTime.ToUniversalTime();
julianDate = new JulianDate(localDateTime);
dateTime = julianDate.ToDateTime();
Assert.AreEqual(utc, dateTime);
}
