public FetchInfo(FetchInfo fetchInfo)
{
Extent = new MRect(fetchInfo.Extent);
Resolution = fetchInfo.Resolution;
CRS = fetchInfo.CRS;
ChangeType = fetchInfo.ChangeType;
}
public void TileFetcherWithFailingFetchesShouldTryAgain()
{
// Arrange
var tileProvider = new FailingTileProvider();
var tileSchema = new GlobalSphericalMercator();
var tileSource = new TileSource(tileProvider, tileSchema);
using var cache = new MemoryCache <IFeature?>();
var fetchDispatcher = new TileFetchDispatcher(cache, tileSource.Schema, async tileInfo => await TileToFeatureAsync(tileSource, tileInfo));
var tileMachine = new FetchMachine(fetchDispatcher);
var level = 3;
var tilesInLevel = 64;
var fetchInfo = new FetchInfo(tileSchema.Extent.ToMRect(), tileSchema.Resolutions[level].UnitsPerPixel);
// Act
fetchDispatcher.SetViewport(fetchInfo);
tileMachine.Start();
while (fetchDispatcher.Busy)
{
Thread.Sleep(1);
}
// Act again
fetchDispatcher.SetViewport(fetchInfo);
tileMachine.Start();
while (fetchDispatcher.Busy)
{
Thread.Sleep(1);
}
// Assert
Assert.AreEqual(tilesInLevel * 2, tileProvider.TotalCount); // tried all tiles twice
}
public void RepeatedRestartsShouldNotCauseInfiniteLoop()
{
// Arrange
var tileProvider = new CountingTileProvider();
var tileSchema = new GlobalSphericalMercator();
var tileSource = new TileSource(tileProvider, tileSchema);
using var cache = new MemoryCache <IFeature?>();
var fetchDispatcher = new TileFetchDispatcher(cache, tileSource.Schema, tileInfo => TileToFeature(tileSource, tileInfo));
var tileMachine = new FetchMachine(fetchDispatcher);
var numberOfWorkers = 8;
var numberOfRestarts = 3;
var fetchInfo = new FetchInfo(tileSchema.Extent.ToMRect(), tileSchema.Resolutions[3].UnitsPerPixel);
// Act
for (var i = 0; i < numberOfRestarts; i++)
{
fetchDispatcher.SetViewport(fetchInfo);
tileMachine.Start();
while (fetchDispatcher.Busy)
{
Thread.Sleep(1);
}
}
// Assert
Assert.Greater(numberOfWorkers * numberOfRestarts, FetchWorker.RestartCounter);
}
public void TestExceptionOnProvider()
{
// arrange
var provider = new FakeProvider();
using var imageLayer = new ImageLayer("imageLayer")
{
DataSource = provider
};
using var map = new Map();
map.Layers.Add(imageLayer);
using var waitHandle = new AutoResetEvent(false);
Exception?exception = null;
imageLayer.DataChanged += (_, args) => {
exception = args.Error;
waitHandle.Go();
};
var fetchInfo = new FetchInfo(new MRect(-1, -1, 0, 0), 1, null, ChangeType.Discrete);
// act
map.RefreshData(fetchInfo);
// assert
waitHandle.WaitOne();
Assert.AreEqual(ExceptionMessage, exception?.Message);
}
public void TestTimer()
{
// arrange
DefaultRendererFactory.Create = () => new MapRenderer();
using var memoryLayer = CreatePointLayer();
using var layer = new RasterizingLayer(memoryLayer);
var schema = new GlobalSphericalMercator();
var box = schema.Extent.ToMRect();
var resolution = schema.Resolutions.First().Value.UnitsPerPixel;
using var waitHandle = new AutoResetEvent(false);
Assert.AreEqual(0, layer.GetFeatures(box, resolution).Count());
layer.DataChanged += (_, _) => {
// assert
waitHandle.Set();
};
var fetchInfo = new FetchInfo(box, resolution, null, ChangeType.Discrete);
// act
layer.RefreshData(fetchInfo);
// assert
waitHandle.WaitOne();
Assert.AreEqual(layer.GetFeatures(box, resolution).Count(), 1);
}
public void TileFetcherShouldRequestAllTilesJustOnes()
{
// Arrange
var tileProvider = new CountingTileProvider();
var tileSchema = new GlobalSphericalMercator();
var tileSource = new TileSource(tileProvider, tileSchema);
using var cache = new MemoryCache <IFeature?>();
var fetchDispatcher = new TileFetchDispatcher(cache, tileSource.Schema, tileInfo => TileToFeature(tileSource, tileInfo));
var tileMachine = new FetchMachine(fetchDispatcher);
var level = 3;
var expectedTiles = 64;
var fetchInfo = new FetchInfo(tileSchema.Extent.ToMRect(), tileSchema.Resolutions[level].UnitsPerPixel);
// Act
// Get all tiles of level 3
fetchDispatcher.SetViewport(fetchInfo);
tileMachine.Start();
// Assert
while (fetchDispatcher.Busy)
{
Thread.Sleep(1);
}
Assert.AreEqual(expectedTiles, tileProvider.CountByTile.Keys.Count);
Assert.AreEqual(expectedTiles, tileProvider.CountByTile.Values.Sum());
Assert.AreEqual(expectedTiles, tileProvider.TotalCount);
}
public void TileRequestThatReturnsNullShouldNotBeRequestedAgain()
{
// Arrange
var tileProvider = new NullTileProvider();
var tileSchema = new GlobalSphericalMercator();
var tileSource = new TileSource(tileProvider, tileSchema);
using var cache = new MemoryCache <IFeature?>();
var fetchDispatcher = new TileFetchDispatcher(cache, tileSource.Schema, tileInfo => TileToFeature(tileSource, tileInfo));
var tileMachine = new FetchMachine(fetchDispatcher);
var level = 3;
var tilesInLevel = 64;
var fetchInfo = new FetchInfo(tileSchema.Extent.ToMRect(), tileSchema.Resolutions[level].UnitsPerPixel);
// Act
fetchDispatcher.SetViewport(fetchInfo);
tileMachine.Start();
while (fetchDispatcher.Busy)
{
Thread.Sleep(1);
}
// do it again
fetchDispatcher.SetViewport(fetchInfo);
tileMachine.Start();
while (fetchDispatcher.Busy)
{
Thread.Sleep(1);
}
// Assert
Assert.AreEqual(tilesInLevel, tileProvider.TotalCount);
}
public async Task TestFeatureFetcherDelayAsync()
{
// arrange
var extent = new MRect(0, 0, 10, 10);
using var layer = new Layer
{
DataSource = new MemoryProvider(GenerateRandomPoints(extent, 25))
};
layer.Delayer.MillisecondsToWait = 0;
var notifications = new List <bool>();
layer.PropertyChanged += (_, args) => {
if (args.PropertyName == nameof(Layer.Busy))
{
notifications.Add(layer.Busy);
}
};
var fetchInfo = new FetchInfo(extent, 1, null, ChangeType.Discrete);
// act
layer.RefreshData(fetchInfo);
// assert
await Task.Run(() => {
while (notifications.Count < 2)
{
// just wait until we have two
}
});
Assert.IsTrue(notifications[0]);
Assert.IsFalse(notifications[1]);
}
public IEnumerable <IFeature> GetFeatures(FetchInfo fetchInfo)
{
// Note that the FetchInfo.CRS is ignored in this method. A better solution
// would be to use the fetchInfo.CRS everywhere, but that would only make
// sense if GetExtent would also get a CRS argument. Room for improvement.
if (fetchInfo.Extent == null)
{
return(new List <IFeature>());
}
var copiedExtent = new MRect(fetchInfo.Extent);
// throws exception when CRS or _provider.CRS is null (so I don't have to check it here)
_projection.Project(CRS !, _provider.CRS !, copiedExtent);
fetchInfo = new FetchInfo(copiedExtent, fetchInfo.Resolution, CRS, fetchInfo.ChangeType);
var features = _provider.GetFeatures(fetchInfo) ?? new List <IFeature>();
if (!CrsHelper.IsProjectionNeeded(_provider.CRS, CRS))
{
return(features);
}
if (!CrsHelper.IsCrsProvided(_provider.CRS, CRS))
{
throw new NotSupportedException($"CRS is not provided. From CRS: {_provider.CRS}. To CRS {CRS}");
}
var copiedFeatures = features.Copy().ToList();
_projection.Project(_provider.CRS, CRS, copiedFeatures);
return(copiedFeatures);
}
public Task <IEnumerable <IFeature> > GetFeaturesAsync(FetchInfo fetchInfo)
{
if (_extent.Intersects(fetchInfo.Extent))
{
return(Task.FromResult((IEnumerable <IFeature>) new[] { _feature }));
}
return(Task.FromResult(Enumerable.Empty <IFeature>()));
}
public IEnumerable <IFeature> GetFeatures(FetchInfo fetchInfo)
{
if (_extent.Intersects(fetchInfo.Extent))
{
return(new[] { _feature });
}
return(new List <IFeature>());
}
public IEnumerable <IFeature> GetFeatures(FetchInfo fetchInfo)
{
var features = new List <RasterFeature>();
if (TryGetMap(fetchInfo.ToViewport(), out var raster))
{
features.Add(new RasterFeature(raster));
}
return(features);
}
/// <inheritdoc />
public void RefreshData(FetchInfo fetchInfo)
{
if (Enabled &&
fetchInfo.Extent?.GetArea() > 0 &&
MaxVisible >= fetchInfo.Resolution &&
MinVisible <= fetchInfo.Resolution)
{
_tileFetchDispatcher.SetViewport(fetchInfo);
_tileFetchDispatcher.StartFetching();
}
}
public async Task <IEnumerable <IFeature> > GetFeaturesAsync(FetchInfo fetchInfo)
{
if (GetFetchInfo(ref fetchInfo))
{
return(Enumerable.Empty <IFeature>());
}
var features = await _provider.GetFeaturesAsync(fetchInfo);
return(features.Project(_provider.CRS, CRS, _projection));
}
public async Task <IEnumerable <IFeature> > GetFeaturesAsync(FetchInfo fetchInfo)
{
var(success, raster) = await TryGetMapAsync(fetchInfo.ToViewport());
if (success)
{
return new[] { new RasterFeature(raster) }
}
;
return(Enumerable.Empty <IFeature>());
}
public FeatureFetcher(FetchInfo fetchInfo, IProvider <IFeature> provider, DataArrivedDelegate dataArrived, long timeOfRequest = default)
{
_dataArrived = dataArrived;
var biggerBox = fetchInfo.Extent.Grow(
SymbolStyle.DefaultWidth * 2 * fetchInfo.Resolution,
SymbolStyle.DefaultHeight * 2 * fetchInfo.Resolution);
_fetchInfo = new FetchInfo(biggerBox, fetchInfo.Resolution, fetchInfo.CRS, fetchInfo.ChangeType);
_provider = provider;
_timeOfRequest = timeOfRequest;
}
public void FetchOnThread(FetchInfo fetchInfo)
{
try
{
var features = DataSource?.GetFeatures(fetchInfo).ToList();
FetchCompleted(features, null);
}
catch (Exception exception)
{
FetchCompleted(null, exception);
}
}
public async Task FetchOnThreadAsync(FetchInfo fetchInfo)
{
try
{
var features = DataSource != null ? await DataSource.GetFeaturesAsync(fetchInfo) : new List <IFeature>();
FetchCompleted(features, null);
}
catch (Exception exception)
{
FetchCompleted(null, exception);
}
}
public void SetViewport(FetchInfo fetchInfo)
{
// Fetch a bigger extent to include partially visible symbols.
// todo: Take into account the maximum symbol size of the layer
var biggerBox = fetchInfo.Extent.Grow(
SymbolStyle.DefaultWidth * 2 * fetchInfo.Resolution,
SymbolStyle.DefaultHeight * 2 * fetchInfo.Resolution);
_fetchInfo = new FetchInfo(biggerBox, fetchInfo.Resolution, fetchInfo.CRS, fetchInfo.ChangeType);
_modified = true;
Busy = true;
}
private bool GetFetchInfo(ref FetchInfo fetchInfo)
{
// Note that the FetchInfo.CRS is ignored in this method. A better solution
// would be to use the fetchInfo.CRS everywhere, but that would only make
// sense if GetExtent would also get a CRS argument. Room for improvement.
if (fetchInfo.Extent == null)
{
return(true);
}
var copiedExtent = new MRect(fetchInfo.Extent);
// throws exception when CRS or _provider.CRS is null (so I don't have to check it here)
_projection.Project(CRS !, _provider.CRS !, copiedExtent);
fetchInfo = new FetchInfo(copiedExtent, fetchInfo.Resolution, CRS, fetchInfo.ChangeType);
return(false);
}
public virtual IEnumerable <T> GetFeatures(FetchInfo fetchInfo)
{
if (fetchInfo == null)
{
throw new ArgumentNullException(nameof(fetchInfo));
}
if (fetchInfo.Extent == null)
{
throw new ArgumentNullException(nameof(fetchInfo.Extent));
}
var features = Features.ToList();
fetchInfo = new FetchInfo(fetchInfo);
// Use a larger extent so that symbols partially outside of the extent are included
var biggerBox = fetchInfo.Extent?.Grow(fetchInfo.Resolution * SymbolSize * 0.5);
var grownFeatures = features.Where(f => f != null && (f.Extent?.Intersects(biggerBox) ?? false));
return(grownFeatures.ToList());
}
public override IEnumerable <IFeature> GetFeatures(MRect box, double resolution)
{
if (box == null)
{
return(Enumerable.Empty <IFeature>());
}
var biggerBox = box.Grow(
SymbolStyle.DefaultWidth * 2 * resolution,
SymbolStyle.DefaultHeight * 2 * resolution);
var fetchInfo = new FetchInfo(biggerBox, resolution, CRS);
if (DataSource is null)
{
return(Enumerable.Empty <IFeature>());
}
#pragma warning disable VSTHRD002 // Allow use of .Result for test purposes
return(DataSource.GetFeaturesAsync(fetchInfo).Result);
#pragma warning restore VSTHRD002 //
}
public void TilesFetchedShouldNotBeFetchAgain()
{
// Arrange
var tileProvider = new CountingTileProvider();
var tileSchema = new GlobalSphericalMercator();
var tileSource = new TileSource(tileProvider, tileSchema);
using var cache = new MemoryCache <IFeature?>();
var fetchDispatcher = new TileFetchDispatcher(cache, tileSource.Schema, tileInfo => TileToFeature(tileSource, tileInfo));
var tileMachine = new FetchMachine(fetchDispatcher);
var level = 3;
var expectedTiles = 64;
var fetchInfo = new FetchInfo(tileSchema.Extent.ToMRect(), tileSchema.Resolutions[level].UnitsPerPixel);
// Act
fetchDispatcher.SetViewport(fetchInfo);
tileMachine.Start();
while (fetchDispatcher.Busy)
{
Thread.Sleep(1);
}
var countAfterFirstTry = tileProvider.CountByTile.Keys.Count;
// do it again
fetchDispatcher.SetViewport(fetchInfo);
tileMachine.Start();
while (fetchDispatcher.Busy)
{
Thread.Sleep(1);
}
// Assert
Assert.AreEqual(countAfterFirstTry, tileProvider.CountByTile.Values.Sum());
Assert.AreEqual(expectedTiles, tileProvider.CountByTile.Keys.Count);
Assert.AreEqual(expectedTiles, tileProvider.CountByTile.Values.Sum());
Assert.AreEqual(expectedTiles, tileProvider.TotalCount);
}
public void TileFetcherWithSometimesFailingFetchesShouldTryAgain()
{
// Arrange
var tileProvider = new SometimesFailingTileProvider();
var tileSchema = new GlobalSphericalMercator();
var tileSource = new TileSource(tileProvider, tileSchema);
using var cache = new MemoryCache <IFeature?>();
var fetchDispatcher = new TileFetchDispatcher(cache, tileSource.Schema, tileInfo => TileToFeature(tileSource, tileInfo));
var tileMachine = new FetchMachine(fetchDispatcher);
var level = 3;
var tilesInLevel = 64;
var fetchInfo = new FetchInfo(tileSchema.Extent.ToMRect(), tileSchema.Resolutions[level].UnitsPerPixel);
// Act
fetchDispatcher.SetViewport(fetchInfo);
tileMachine.Start();
while (fetchDispatcher.Busy)
{
Thread.Sleep(1);
}
var tileCountAfterFirstBatch = tileProvider.TotalCount;
// Act again
fetchDispatcher.SetViewport(fetchInfo);
tileMachine.Start();
while (fetchDispatcher.Busy)
{
Thread.Sleep(1);
}
// Assert
Assert.GreaterOrEqual(tileProvider.TotalCount, tileCountAfterFirstBatch);
Assert.GreaterOrEqual(tileProvider.CountByTile.Values.Sum(), tilesInLevel);
}
public FetchInfo(FetchInfo rhs)
{
this.State = rhs.State;
this.Since = rhs.Since;
this.RequestType = rhs.RequestType;
}
public Task <IEnumerable <IFeature> > GetFeaturesAsync(FetchInfo fetchInfo)
{
throw new Exception(ExceptionMessage);
}
public override void RefreshData(FetchInfo fetchInfo)
{
OnDataChanged(new DataChangedEventArgs());
}
public async Task <IEnumerable <IFeature> > GetFeaturesAsync(FetchInfo fetchInfo)
{
var features = await _provider.GetFeaturesAsync(fetchInfo);
return(GetFeaturesInView(fetchInfo.Resolution, _labelStyle, features, _rectangleLine, _rectangleFill));
}
public IEnumerable <IFeature> GetFeatures(FetchInfo fetchInfo)
{
throw new Exception(ExceptionMessage);
}
public static Viewport ToViewport(this FetchInfo fetchInfo)
{
return(Viewport.Create(fetchInfo.Extent, fetchInfo.Resolution));
}
public uint Whitelist; // bitmask flags, see WL_ALL
#endregion Fields
#region Constructors
public PlayerModel()
{
Name = null;
Team = -1;
Squad = -1;
EAGUID = String.Empty;
FirstSeenTimestamp = DateTime.Now;
FirstSpawnTimestamp = DateTime.MinValue;
LastSeenTimestamp = DateTime.MinValue;
Tag = String.Empty;
TagVerified = false;
ScoreRound = -1;
KillsRound = -1;
DeathsRound = -1;
Rounds = -1;
Rank = -1;
KDRRound = -1;
SPMRound = -1;
KPMRound = -1;
ScoreTotal = 0;
KillsTotal = 0;
DeathsTotal = 0;
MovesTotal = 0;
MovesByMBTotal = 0;
IsDeployed = false;
MovesRound = 0;
MovesByMBRound = 0;
MovedTimestamp = DateTime.MinValue;
MovedByMBTimestamp = DateTime.MinValue;
SpawnChatMessage = String.Empty;
SpawnYellMessage = String.Empty;
QuietMessage = false;
DelayedMove = null;
LastMoveTo = 0;
LastMoveFrom = 0;
TagFetchStatus = new FetchInfo();
ScrambledSquad = -1;
OriginalSquad = -1;
DispersalGroup = 0;
Friendex = -1;
KDR = -1;
SPM = -1;
KPM = -1;
StatsVerified = false;
PersonaId = String.Empty;
StatsFetchStatus = new FetchInfo();
Subscribed = false;
Whitelist = 0;
}
public IEnumerable <IFeature> GetFeatures(FetchInfo fetchInfo)
{
var features = _provider.GetFeatures(fetchInfo);
return(GetFeaturesInView(fetchInfo.Resolution, _labelStyle, features, _rectangleLine, _rectangleFill));
}
