private void CreateReplay(Session session, KmlExportDocument parentDocument, int sessionCount, XmlWriter writer, IFormatProvider formatProvider)
{
if (KmlProperties.ReplayType == KmlExportReplayType.None) return;
CreateFolderElement(Strings.Replay, false, writer, formatProvider);
writer.WriteElementString("styleUrl", "#rfi" + sessionCount);
// markers
if (KmlProperties.HasReplayTails)
{
CreateFolderElement(Strings.ReplayPosition, false, writer, formatProvider);
writer.WriteElementString("styleUrl", "#rmi" + sessionCount);
}
CreateReplayMarkers(session, parentDocument, writer, formatProvider);
if (KmlProperties.HasReplayTails) writer.WriteEndElement();
// tail(s)
foreach (var tail in KmlProperties.ReplayTails)
{
CreateFolderElement(Strings.ReplayTail, false, writer, formatProvider);
writer.WriteElementString("styleUrl", "#rti" + sessionCount);
CreateReplayTails(session, parentDocument, tail, writer, formatProvider);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
private void CreateReplayMarkers(Session session, KmlExportDocument parentDocument, XmlWriter writer, IFormatProvider formatProvider)
{
LogUtil.LogDebug("");
var sessionSettings = parentDocument.ImageExporter.Properties.SessionSettings ?? session.Settings;
KmlMarkerStyle markerStyle = null;
if (KmlProperties.ReplayType == KmlExportReplayType.Monochrome)
{
markerStyle = GetReplayMarkerStyleForSession(session);
}
var route = GetRouteForSession(session, parentDocument);
foreach (var segment in route.Segments)
{
var waypoints = route.GetEquallySpacedWaypoints(segment.FirstWaypoint.Time, segment.LastWaypoint.Time,
KmlProperties.ReplayTimeInterval);
foreach (var waypoint in waypoints)
{
// when should the marker disappear?
DateTime? markerDisappearTime = segment.LastWaypoint.Time; // default value
if (waypoint.Time.Add(KmlProperties.ReplayTimeInterval) <= segment.LastWaypoint.Time)
{
// subtract a millisecond from the time to prevent double occurences of markers
markerDisappearTime = waypoint.Time.Add(KmlProperties.ReplayTimeInterval).Subtract(new TimeSpan(TimeSpan.TicksPerMillisecond));
}
// create the marker
if (KmlProperties.ReplayType == KmlExportReplayType.ColorCoded)
{
markerStyle = GetMarkerStyleFromWaypoint(waypoint, parentDocument.ImageExporter, sessionSettings);
}
CreateReplayPlacemark(waypoint, markerStyle, waypoint.Time, markerDisappearTime,
writer, formatProvider);
}
}
}
private void CreateGroundOverlay(KmlExportDocument kmlExportDocument, int documentCount, XmlWriter writer, IFormatProvider formatProvider)
{
if (GroundOverlays[kmlExportDocument] == null) return;
writer.WriteStartElement("GroundOverlay");
writer.WriteElementString("name", Strings.Map);
writer.WriteElementString("styleUrl", "#oi" + documentCount);
writer.WriteStartElement("Icon");
writer.WriteElementString("href", GetGroundOverlayUrl(kmlExportDocument));
writer.WriteEndElement();
var orthogonallyRotatedCorners = GetOrthogonallyRotatedCorners(kmlExportDocument);
if (orthogonallyRotatedCorners != null)
{
writer.WriteStartElement("LatLonBox");
writer.WriteElementString("north", Math.Max(orthogonallyRotatedCorners[1].Latitude, orthogonallyRotatedCorners[2].Latitude).ToString(formatProvider));
writer.WriteElementString("south", Math.Min(orthogonallyRotatedCorners[0].Latitude, orthogonallyRotatedCorners[3].Latitude).ToString(formatProvider));
writer.WriteElementString("east", Math.Max(orthogonallyRotatedCorners[2].Longitude, orthogonallyRotatedCorners[3].Longitude).ToString(formatProvider));
writer.WriteElementString("west", Math.Min(orthogonallyRotatedCorners[0].Longitude, orthogonallyRotatedCorners[1].Longitude).ToString(formatProvider));
writer.WriteElementString("rotation", GetImageRotationD(kmlExportDocument).ToString(formatProvider));
writer.WriteEndElement();
}
writer.WriteEndElement(); // GroundOverlay
}
private void CreateMonochromeRouteLines(Session session, KmlExportDocument parentDocument, XmlWriter writer, IFormatProvider formatProvider)
{
foreach (var segment in GetRouteForSession(session, parentDocument).Segments)
{
CreateLineStringPlacemark(segment.Waypoints, GetRouteLineStyleForSession(session), writer, formatProvider);
}
}
/// <summary>
/// Gets the corners of the map if the map has a rotation of 0, i e are aligned to the longitude and latitude axes.
/// </summary>
/// <param name="kmlExportDocument"></param>
/// <returns></returns>
private static LongLat[] GetOrthogonallyRotatedCorners(KmlExportDocument kmlExportDocument)
{
var document = kmlExportDocument.Document;
var corners = document.GetImageCornersLongLat(kmlExportDocument.ImageExporter.ImageBounds, kmlExportDocument.ImageExporter.MapBounds,
kmlExportDocument.ImageExporter.Properties.PercentualSize);
var rotationD = GetImageRotationD(kmlExportDocument);
var rotationR = LinearAlgebraUtil.ToRadians(rotationD);
if (corners != null)
{
// need to align map in north-south direction; rotate map around its center
var center = (corners[0] / 4 + corners[1] / 4 + corners[2] / 4 + corners[3] / 4);
var projectedCenter = center.Project(document.ProjectionOrigin);
var projectedOrthogonallyRotatedCorners = new[]
{
LinearAlgebraUtil.Rotate(corners[0].Project(document.ProjectionOrigin), projectedCenter, rotationR),
LinearAlgebraUtil.Rotate(corners[1].Project(document.ProjectionOrigin), projectedCenter, rotationR),
LinearAlgebraUtil.Rotate(corners[2].Project(document.ProjectionOrigin), projectedCenter, rotationR),
LinearAlgebraUtil.Rotate(corners[3].Project(document.ProjectionOrigin), projectedCenter, rotationR),
};
var orthogonallyRotatedCorners = new[]
{
LongLat.Deproject(projectedOrthogonallyRotatedCorners[0], document.ProjectionOrigin),
LongLat.Deproject(projectedOrthogonallyRotatedCorners[1], document.ProjectionOrigin),
LongLat.Deproject(projectedOrthogonallyRotatedCorners[2], document.ProjectionOrigin),
LongLat.Deproject(projectedOrthogonallyRotatedCorners[3], document.ProjectionOrigin),
};
return orthogonallyRotatedCorners;
}
return null;
}
private void CreateColorCodedRouteLines(Session session, KmlExportDocument parentDocument, XmlWriter writer, IFormatProvider formatProvider)
{
var sessionSettings = parentDocument.ImageExporter.Properties.SessionSettings ?? session.Settings;
foreach (var segment in GetRouteForSession(session, parentDocument).Segments)
{
var lineWaypoints = new List<Waypoint>();
Waypoint previousWaypoint = null;
KmlLineStyle previousLineStyle = null;
foreach (var waypoint in segment.Waypoints)
{
if (previousWaypoint == null)
{
previousWaypoint = waypoint;
lineWaypoints.Add(waypoint);
continue; // skip first waypoint
}
// continue with this line or create new line with different color?
previousLineStyle = GetLineStyleFromWaypoint(previousWaypoint, parentDocument.ImageExporter, sessionSettings);
var lineStyle = GetLineStyleFromWaypoint(waypoint, parentDocument.ImageExporter, sessionSettings);
if (lineStyle.Equals(previousLineStyle))
{
// add line segment to current line
lineWaypoints.Add(waypoint);
}
else
{
lineWaypoints.Add(waypoint);
CreateLineStringPlacemark(lineWaypoints, previousLineStyle, writer, formatProvider);
lineWaypoints = new List<Waypoint>() { waypoint }; // create new line with this waypoint as start point
}
previousWaypoint = waypoint;
}
// add last line
CreateLineStringPlacemark(lineWaypoints, previousLineStyle, writer, formatProvider);
}
}
private static double GetImageRotationD(KmlExportDocument kmlExportDocument)
{
var document = kmlExportDocument.Document;
var corners = document.GetImageCornersLongLat(kmlExportDocument.ImageExporter.ImageBounds, kmlExportDocument.ImageExporter.MapBounds,
kmlExportDocument.ImageExporter.Properties.PercentualSize);
var sw = corners[0].Project(document.ProjectionOrigin);
var se = corners[3].Project(document.ProjectionOrigin);
return LinearAlgebraUtil.GetAngleD(se - sw);
}
private Route GetRouteForSession(Session session, KmlExportDocument parentDocument)
{
if (KmlProperties.RouteAdaptionStyle != KmlRouteAdaptationStyle.NoAdaption && KmlProperties.MapType != KmlExportMapType.None)
{
if (!adaptedRoutes.ContainsKey(session))
{
var baseSession = parentDocument == null || parentDocument.Sessions.Count == 0 || KmlProperties.RouteAdaptionStyle == KmlRouteAdaptationStyle.AdaptToSessionMapImage
? session
: parentDocument.Sessions[0];
adaptedRoutes[session] = session.CreateRouteAdaptedToSingleTransformationMatrix(baseSession);
}
return adaptedRoutes[session];
}
return session.Route;
}
private string GetGroundOverlayUrl(KmlExportDocument kmlExportDocument)
{
if (GroundOverlays.ContainsKey(kmlExportDocument))
{
var go = GroundOverlays[kmlExportDocument];
switch (go.Type)
{
case KmlGroundOverlay.GroundOverlayType.Url:
return go.Href;
case KmlGroundOverlay.GroundOverlayType.File:
var href = Path.GetFileName(go.Href);
kmzFile.AddFile(go.Href, "");
return href;
}
}
return null;
}
private void CreateRouteLines(Session session, KmlExportDocument parentDocument, int sessionCount, XmlWriter writer, IFormatProvider formatProvider)
{
if (KmlProperties.RouteType == KmlExportRouteType.None) return;
CreateFolderElement(Strings.Route, false, writer, formatProvider);
writer.WriteElementString("styleUrl", "#ri" + sessionCount);
switch (KmlProperties.RouteType)
{
case KmlExportRouteType.Monochrome:
CreateMonochromeRouteLines(session, parentDocument, writer, formatProvider);
break;
case KmlExportRouteType.ColorCoded:
CreateColorCodedRouteLines(session, parentDocument, writer, formatProvider);
break;
}
writer.WriteEndElement();
}
private void CreateReplayTails(Session session, KmlExportDocument parentDocument, KmlReplayTail templateTail, XmlWriter writer, IFormatProvider formatProvider)
{
LogUtil.LogDebug("start");
var sessionSettings = parentDocument.ImageExporter.Properties.SessionSettings ?? session.Settings;
KmlLineStyle routeLineStyle = null;
if (KmlProperties.ReplayType == KmlExportReplayType.Monochrome)
{
routeLineStyle = templateTail.RouteLineStyle ?? GetRouteLineStyleForSession(session);
}
var route = GetRouteForSession(session, parentDocument);
foreach (var segment in route.Segments)
{
var waypoints = route.GetEquallySpacedWaypoints(segment.FirstWaypoint.Time, segment.LastWaypoint.Time,
KmlProperties.ReplayTimeInterval);
for (var i = 1; i < waypoints.Count; i++)
{
var lastWaypoint = waypoints[i - 1];
var waypoint = waypoints[i];
// create tail
DateTime? lineAppearTime = null;
DateTime? lineDisappearTime = null;
if (templateTail.StartVisible.HasValue)
{
lineAppearTime = waypoint.Time.Add(templateTail.StartVisible.Value);
if (lineAppearTime < segment.FirstWaypoint.Time.Add(templateTail.StartVisible.Value)) lineAppearTime = segment.FirstWaypoint.Time;
if (lineAppearTime > segment.LastWaypoint.Time.Add(templateTail.StartVisible.Value)) lineAppearTime = segment.LastWaypoint.Time;
}
if (templateTail.EndVisible.HasValue)
{
// subtract a millisecond from the time to ensure tail disappears correctly
lineDisappearTime = waypoint.Time.Add(templateTail.EndVisible.Value).Subtract(new TimeSpan(TimeSpan.TicksPerMillisecond));
if (lineDisappearTime < segment.FirstWaypoint.Time.Add(templateTail.EndVisible.Value)) lineDisappearTime = segment.FirstWaypoint.Time;
if (lineDisappearTime > segment.LastWaypoint.Time.Add(templateTail.EndVisible.Value)) lineDisappearTime = segment.LastWaypoint.Time;
}
if (KmlProperties.ReplayType == KmlExportReplayType.ColorCoded)
{
routeLineStyle = GetLineStyleFromWaypoint(waypoint, parentDocument.ImageExporter, sessionSettings);
}
CreateLineStringPlacemark(new[] { lastWaypoint, waypoint }, routeLineStyle,
lineAppearTime, lineDisappearTime, writer, formatProvider);
}
}
LogUtil.LogDebug("end");
}
