ClemensFischer/XAML-Map-Control
1
0
Fork 0
mirror of https://github.com/ClemensFischer/XAML-Map-Control.git synced 2026-04-03 12:00:04 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Version 4.12.2 Improved ImageLoader/TileImageLoader

Browse source
This commit is contained in:
ClemensF 2019-07-13 19:53:03 +02:00
parent 4a7e384152
commit fefc4e3294
9 changed files with 102 additions and 171 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
MapControl/Shared/ImageLoader.cs
View file

@ -6,7 +6,6 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics; using System.Diagnostics;
using System.Linq; using System.Linq;
using System.IO;
using System.Net.Http; using System.Net.Http;
using System.Threading.Tasks; using System.Threading.Tasks;
#if WINDOWS_UWP #if WINDOWS_UWP
@ -22,7 +21,7 @@ namespace MapControl
public static partial class ImageLoader public static partial class ImageLoader
{ {
/// <summary> /// <summary>
/// The System.Net.Http.HttpClient instance used when image data is downloaded via a http or https Uri. /// The System.Net.Http.HttpClient instance used to download images via a http or https Uri.
/// </summary> /// </summary>
public static HttpClient HttpClient { get; set; } = new HttpClient(); public static HttpClient HttpClient { get; set; } = new HttpClient();
@ -41,12 +40,9 @@ namespace MapControl
{ {
var response = await GetHttpResponseAsync(uri); var response = await GetHttpResponseAsync(uri);
if (response?.Stream != null) if (response != null && response.Buffer != null)
{ {
using (var stream = response.Stream) image = await LoadImageAsync(response.Buffer);
{
image = await LoadImageAsync(stream);
}
} }
} }
else else
@ -90,7 +86,7 @@ namespace MapControl
internal class HttpResponse internal class HttpResponse
{ {
public MemoryStream Stream { get; private set; } public byte[] Buffer { get; private set; }
public TimeSpan? MaxAge { get; private set; } public TimeSpan? MaxAge { get; private set; }
internal static async Task<HttpResponse> Create(HttpResponseMessage message, bool continueOnCapturedContext) internal static async Task<HttpResponse> Create(HttpResponseMessage message, bool continueOnCapturedContext)
@ -100,9 +96,7 @@ namespace MapControl
if (!message.Headers.TryGetValues("X-VE-Tile-Info", out tileInfo) || !tileInfo.Contains("no-tile")) if (!message.Headers.TryGetValues("X-VE-Tile-Info", out tileInfo) || !tileInfo.Contains("no-tile"))
{ {
response.Stream = new MemoryStream(); response.Buffer = await message.Content.ReadAsByteArrayAsync().ConfigureAwait(continueOnCapturedContext);
await message.Content.CopyToAsync(response.Stream).ConfigureAwait(continueOnCapturedContext);
response.Stream.Seek(0, SeekOrigin.Begin);
response.MaxAge = message.Headers.CacheControl?.MaxAge; response.MaxAge = message.Headers.CacheControl?.MaxAge;
} }

2
MapControl/Shared/TileImageLoader.cs
View file

@ -107,7 +107,7 @@ namespace MapControl
try try
{ {
Debug.WriteLine("TileImageLoader: loading {0}/{1}/{2} in thread {3}", tile.ZoomLevel, tile.XIndex, tile.Y, Environment.CurrentManagedThreadId); //Debug.WriteLine("TileImageLoader: loading {0}/{1}/{2} in thread {3}", tile.ZoomLevel, tile.XIndex, tile.Y, Environment.CurrentManagedThreadId);
await loadTileImage(tile).ConfigureAwait(false); await loadTileImage(tile).ConfigureAwait(false);
} }

19
MapControl/UWP/ImageLoader.UWP.cs
View file

@ -15,11 +15,6 @@ namespace MapControl
{ {
public static partial class ImageLoader public static partial class ImageLoader
{ {
public static Task<ImageSource> LoadImageAsync(Stream stream)
{
return LoadImageAsync(stream.AsRandomAccessStream());
}
public static async Task<ImageSource> LoadImageAsync(IRandomAccessStream stream) public static async Task<ImageSource> LoadImageAsync(IRandomAccessStream stream)
{ {
var image = new BitmapImage(); var image = new BitmapImage();
@ -29,11 +24,11 @@ namespace MapControl
return image; return image;
} }
public static async Task<ImageSource> LoadImageAsync(byte[] buffer) public static async Task<ImageSource> LoadImageAsync(IBuffer buffer)
{ {
using (var stream = new InMemoryRandomAccessStream()) using (var stream = new InMemoryRandomAccessStream())
{ {
await stream.WriteAsync(buffer.AsBuffer()); await stream.WriteAsync(buffer);
stream.Seek(0); stream.Seek(0);
return await LoadImageAsync(stream); return await LoadImageAsync(stream);
@ -56,5 +51,15 @@ namespace MapControl
return image; return image;
} }
public static Task<ImageSource> LoadImageAsync(Stream stream)
{
return LoadImageAsync(stream.AsRandomAccessStream());
}
public static Task<ImageSource> LoadImageAsync(byte[] buffer)
{
return LoadImageAsync(buffer.AsBuffer());
}
} }
} }

26
MapControl/UWP/TileImageLoader.UWP.cs
View file

@ -6,7 +6,6 @@ using System;
using System.Runtime.InteropServices.WindowsRuntime; using System.Runtime.InteropServices.WindowsRuntime;
using System.Threading.Tasks; using System.Threading.Tasks;
using Windows.Storage; using Windows.Storage;
using Windows.Storage.Streams;
using Windows.UI.Core; using Windows.UI.Core;
using Windows.UI.Xaml.Media; using Windows.UI.Xaml.Media;
@ -32,37 +31,26 @@ namespace MapControl
private static async Task LoadCachedTileImageAsync(Tile tile, Uri uri, string cacheKey) private static async Task LoadCachedTileImageAsync(Tile tile, Uri uri, string cacheKey)
{ {
var cacheItem = await Cache.GetAsync(cacheKey).ConfigureAwait(false); var cacheItem = await Cache.GetAsync(cacheKey).ConfigureAwait(false);
var cacheBuffer = cacheItem?.Buffer; var buffer = cacheItem?.Buffer;
if (cacheBuffer == null || cacheItem.Expiration < DateTime.UtcNow) if (buffer == null || cacheItem.Expiration < DateTime.UtcNow)
{ {
var response = await ImageLoader.GetHttpResponseAsync(uri, false).ConfigureAwait(false); var response = await ImageLoader.GetHttpResponseAsync(uri, false).ConfigureAwait(false);
if (response != null) // download succeeded if (response != null) // download succeeded
{ {
cacheBuffer = null; // discard cached image buffer = response.Buffer.AsBuffer();
if (response.Stream != null) // tile image available if (buffer != null) // tile image available
{ {
using (var stream = response.Stream) await Cache.SetAsync(cacheKey, buffer, GetExpiration(response.MaxAge)).ConfigureAwait(false);
{
await SetTileImageAsync(tile, () => ImageLoader.LoadImageAsync(stream)).ConfigureAwait(false);
await Cache.SetAsync(cacheKey, stream.ToArray().AsBuffer(), GetExpiration(response.MaxAge)).ConfigureAwait(false);
}
} }
} }
} }
if (cacheBuffer != null) // cached image not expired or download failed if (buffer != null)
{ {
using (var stream = new InMemoryRandomAccessStream()) await SetTileImageAsync(tile, () => ImageLoader.LoadImageAsync(buffer)).ConfigureAwait(false);
{
await stream.WriteAsync(cacheBuffer);
stream.Seek(0);
await SetTileImageAsync(tile, () => ImageLoader.LoadImageAsync(stream)).ConfigureAwait(false);
}
} }
} }

2
MapControl/WPF/ImageFileCache.WPF.cs
View file

@ -107,6 +107,7 @@ namespace MapControl.Caching
try try
{ {
//Debug.WriteLine("ImageFileCache: Reading " + path); //Debug.WriteLine("ImageFileCache: Reading " + path);
buffer = File.ReadAllBytes(path); buffer = File.ReadAllBytes(path);
memoryCache.Set(key, buffer, new CacheItemPolicy()); memoryCache.Set(key, buffer, new CacheItemPolicy());
} }
@ -160,6 +161,7 @@ namespace MapControl.Caching
try try
{ {
//Debug.WriteLine("ImageFileCache: Writing {0}, Expires {1}", path, policy.AbsoluteExpiration.DateTime.ToLocalTime()); //Debug.WriteLine("ImageFileCache: Writing {0}, Expires {1}", path, policy.AbsoluteExpiration.DateTime.ToLocalTime());
Directory.CreateDirectory(Path.GetDirectoryName(path)); Directory.CreateDirectory(Path.GetDirectoryName(path));
File.WriteAllBytes(path, buffer); File.WriteAllBytes(path, buffer);

50
MapControl/WPF/TileImageLoader.WPF.cs
View file

@ -30,40 +30,27 @@ namespace MapControl
private static async Task LoadCachedTileImageAsync(Tile tile, Uri uri, string cacheKey) private static async Task LoadCachedTileImageAsync(Tile tile, Uri uri, string cacheKey)
{ {
ImageSource image = null;
DateTime expiration; DateTime expiration;
byte[] cacheBuffer; var buffer = GetCachedImage(cacheKey, out expiration);
GetCachedImage(cacheKey, out cacheBuffer, out expiration); if (buffer == null || expiration < DateTime.UtcNow)
if (cacheBuffer == null || expiration < DateTime.UtcNow)
{ {
var response = await ImageLoader.GetHttpResponseAsync(uri, false).ConfigureAwait(false); var response = await ImageLoader.GetHttpResponseAsync(uri, false).ConfigureAwait(false);
if (response != null) // download succeeded if (response != null) // download succeeded
{ {
cacheBuffer = null; // discard cached image buffer = response.Buffer;
if (response.Stream != null) // tile image available if (buffer != null) // tile image available
{ {
using (var stream = response.Stream) await SetCachedImage(cacheKey, buffer, GetExpiration(response.MaxAge)).ConfigureAwait(false);
{
image = ImageLoader.LoadImage(stream);
SetCachedImage(cacheKey, stream, GetExpiration(response.MaxAge));
}
} }
} }
} }
if (cacheBuffer != null) // cached image not expired or download failed if (buffer != null)
{ {
image = ImageLoader.LoadImage(cacheBuffer); SetTileImageAsync(tile, await ImageLoader.LoadImageAsync(buffer).ConfigureAwait(false));
}
if (image != null)
{
SetTileImage(tile, image);
} }
} }
@ -73,18 +60,18 @@ namespace MapControl
if (image != null) if (image != null)
{ {
SetTileImage(tile, image); SetTileImageAsync(tile, image);
} }
} }
private static void SetTileImage(Tile tile, ImageSource image) private static void SetTileImageAsync(Tile tile, ImageSource image)
{ {
tile.Image.Dispatcher.InvokeAsync(() => tile.SetImage(image)); tile.Image.Dispatcher.InvokeAsync(() => tile.SetImage(image));
} }
private static void GetCachedImage(string cacheKey, out byte[] buffer, out DateTime expiration) private static byte[] GetCachedImage(string cacheKey, out DateTime expiration)
{ {
buffer = Cache.Get(cacheKey) as byte[]; var buffer = Cache.Get(cacheKey) as byte[];
if (buffer != null && buffer.Length >= 16 && if (buffer != null && buffer.Length >= 16 &&
Encoding.ASCII.GetString(buffer, buffer.Length - 16, 8) == "EXPIRES:") Encoding.ASCII.GetString(buffer, buffer.Length - 16, 8) == "EXPIRES:")
@ -95,15 +82,20 @@ namespace MapControl
{ {
expiration = DateTime.MinValue; expiration = DateTime.MinValue;
} }
return buffer;
} }
private static void SetCachedImage(string cacheKey, MemoryStream stream, DateTime expiration) private static async Task SetCachedImage(string cacheKey, byte[] buffer, DateTime expiration)
{ {
stream.Seek(0, SeekOrigin.End); using (var stream = new MemoryStream(buffer.Length + 16))
stream.Write(Encoding.ASCII.GetBytes("EXPIRES:"), 0, 8); {
stream.Write(BitConverter.GetBytes(expiration.Ticks), 0, 8); await stream.WriteAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
await stream.WriteAsync(Encoding.ASCII.GetBytes("EXPIRES:"), 0, 8).ConfigureAwait(false);
await stream.WriteAsync(BitConverter.GetBytes(expiration.Ticks), 0, 8).ConfigureAwait(false);
Cache.Set(cacheKey, stream.ToArray(), new CacheItemPolicy { AbsoluteExpiration = expiration }); Cache.Set(cacheKey, stream.ToArray(), new CacheItemPolicy { AbsoluteExpiration = expiration });
}
} }
} }
} }

49
MapImages/Shared/GroundOverlayPanel.cs
View file

@ -7,6 +7,7 @@ using System.Collections.Generic;
using System.Diagnostics; using System.Diagnostics;
using System.Globalization; using System.Globalization;
using System.IO; using System.IO;
using System.IO.Compression;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using System.Xml; using System.Xml;
@ -119,7 +120,49 @@ namespace MapControl.Images
} }
} }
private IEnumerable<ImageOverlay> ReadGroundOverlays(XmlDocument kmlDocument) private static async Task<IEnumerable<ImageOverlay>> ReadGroundOverlaysFromArchiveAsync(string archiveFile)
{
using (var archive = ZipFile.OpenRead(archiveFile))
{
var docEntry = archive.GetEntry("doc.kml")
?? archive.Entries.FirstOrDefault(e => e.Name.EndsWith(".kml"));
if (docEntry == null)
{
throw new ArgumentException("No KML entry found in " + archiveFile);
}
var kmlDocument = new XmlDocument();
using (var docStream = docEntry.Open())
{
kmlDocument.Load(docStream);
}
var imageOverlays = await Task.Run(() => ReadGroundOverlays(kmlDocument).ToList());
foreach (var imageOverlay in imageOverlays)
{
var imageEntry = archive.GetEntry(imageOverlay.ImagePath);
if (imageEntry != null)
{
using (var zipStream = imageEntry.Open())
using (var memoryStream = new MemoryStream())
{
await zipStream.CopyToAsync(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
imageOverlay.ImageSource = await ImageLoader.LoadImageAsync(memoryStream);
}
}
}
return imageOverlays;
}
}
private static IEnumerable<ImageOverlay> ReadGroundOverlays(XmlDocument kmlDocument)
{ {
foreach (XmlElement groundOverlayElement in kmlDocument.GetElementsByTagName("GroundOverlay")) foreach (XmlElement groundOverlayElement in kmlDocument.GetElementsByTagName("GroundOverlay"))
{ {
@ -150,7 +193,7 @@ namespace MapControl.Images
} }
} }
private string ReadImagePath(XmlElement element) private static string ReadImagePath(XmlElement element)
{ {
string href = null; string href = null;
@ -167,7 +210,7 @@ namespace MapControl.Images
return href; return href;
} }
private LatLonBox ReadLatLonBox(XmlElement element) private static LatLonBox ReadLatLonBox(XmlElement element)
{ {
double north = double.NaN; double north = double.NaN;
double south = double.NaN; double south = double.NaN;

44
MapImages/UWP/GroundOverlayPanel.UWP.cs
View file

@ -5,7 +5,6 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.IO.Compression;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using System.Xml; using System.Xml;
@ -20,7 +19,7 @@ namespace MapControl.Images
UseLayoutRounding = false; UseLayoutRounding = false;
} }
private async Task<IEnumerable<ImageOverlay>> ReadGroundOverlaysFromFileAsync(string docFile) private static async Task<IEnumerable<ImageOverlay>> ReadGroundOverlaysFromFileAsync(string docFile)
{ {
docFile = Path.GetFullPath(docFile); docFile = Path.GetFullPath(docFile);
@ -42,46 +41,5 @@ namespace MapControl.Images
return imageOverlays; return imageOverlays;
} }
private async Task<IEnumerable<ImageOverlay>> ReadGroundOverlaysFromArchiveAsync(string archiveFile)
{
using (var archive = ZipFile.OpenRead(archiveFile))
{
var docEntry = archive.GetEntry("doc.kml")
?? archive.Entries.FirstOrDefault(e => e.Name.EndsWith(".kml"));
if (docEntry == null)
{
throw new ArgumentException("No KML entry found in " + archiveFile);
}
var kmlDocument = new XmlDocument();
using (var docStream = docEntry.Open())
{
kmlDocument.Load(docStream);
}
var imageOverlays = await Task.Run(() => ReadGroundOverlays(kmlDocument).ToList());
foreach (var imageOverlay in imageOverlays)
{
var imageEntry = archive.GetEntry(imageOverlay.ImagePath);
if (imageEntry != null)
{
using (var zipStream = imageEntry.Open())
using (var memoryStream = new MemoryStream())
{
await zipStream.CopyToAsync(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
imageOverlay.ImageSource = await ImageLoader.LoadImageAsync(memoryStream.AsRandomAccessStream());
}
}
}
return imageOverlays;
}
}
} }
} }

65
MapImages/WPF/GroundOverlayPanel.WPF.cs
View file

@ -2,10 +2,8 @@
// © 2019 Clemens Fischer // © 2019 Clemens Fischer
// Licensed under the Microsoft Public License (Ms-PL) // Licensed under the Microsoft Public License (Ms-PL)
using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.IO.Compression;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using System.Xml; using System.Xml;
@ -14,74 +12,25 @@ namespace MapControl.Images
{ {
public partial class GroundOverlayPanel public partial class GroundOverlayPanel
{ {
private Task<List<ImageOverlay>> ReadGroundOverlaysFromFileAsync(string docFile) private static Task<List<ImageOverlay>> ReadGroundOverlaysFromFileAsync(string docFile)
{ {
return Task.Run(() => ReadGroundOverlaysFromFile(docFile)); return Task.Run(() =>
}
private Task<List<ImageOverlay>> ReadGroundOverlaysFromArchiveAsync(string archiveFile)
{
return Task.Run(() => ReadGroundOverlaysFromArchive(archiveFile));
}
private List<ImageOverlay> ReadGroundOverlaysFromFile(string docFile)
{
docFile = Path.GetFullPath(docFile);
var kmlDocument = new XmlDocument();
kmlDocument.Load(docFile);
var imageOverlays = ReadGroundOverlays(kmlDocument).ToList();
var docDir = Path.GetDirectoryName(docFile);
foreach (var imageOverlay in imageOverlays)
{ {
imageOverlay.ImageSource = ImageLoader.LoadImage(Path.Combine(docDir, imageOverlay.ImagePath)); docFile = Path.GetFullPath(docFile);
}
return imageOverlays;
}
private List<ImageOverlay> ReadGroundOverlaysFromArchive(string archiveFile)
{
using (var archive = ZipFile.OpenRead(archiveFile))
{
var docEntry = archive.GetEntry("doc.kml")
?? archive.Entries.FirstOrDefault(e => e.Name.EndsWith(".kml"));
if (docEntry == null)
{
throw new ArgumentException("No KML entry found in " + archiveFile);
}
var kmlDocument = new XmlDocument(); var kmlDocument = new XmlDocument();
kmlDocument.Load(docFile);
using (var docStream = docEntry.Open())
{
kmlDocument.Load(docStream);
}
var imageOverlays = ReadGroundOverlays(kmlDocument).ToList(); var imageOverlays = ReadGroundOverlays(kmlDocument).ToList();
var docDir = Path.GetDirectoryName(docFile);
foreach (var imageOverlay in imageOverlays) foreach (var imageOverlay in imageOverlays)
{ {
var imageEntry = archive.GetEntry(imageOverlay.ImagePath); imageOverlay.ImageSource = ImageLoader.LoadImage(Path.Combine(docDir, imageOverlay.ImagePath));
if (imageEntry != null)
{
using (var zipStream = imageEntry.Open())
using (var memoryStream = new MemoryStream())
{
zipStream.CopyTo(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
imageOverlay.ImageSource = ImageLoader.LoadImage(memoryStream);
}
}
} }
return imageOverlays; return imageOverlays;
} });
} }
} }
} }