private void OnFinishRenderingTile(object sender, TileProgressEventArgs args)
{
m_tileRuns.Add(DateTime.Now - m_beginTile);
m_tileCount++;
m_grandTotalTileCount++;
//Update display, after 1000 tiles
if (m_tileRuns.Count > 500 || (DateTime.Now - m_lastUpdate).TotalSeconds > 5 || m_cancel)
{
long d = 0;
foreach (TimeSpan ts in m_tileRuns)
{
d += ts.Ticks;
}
d /= m_tileRuns.Count;
//For all other than the first calculation, we use the previous counts too
if (m_grandTotalTileCount != m_tileRuns.Count)
{
d = (d + m_prevDuration.Ticks) / 2;
}
m_prevDuration = new TimeSpan(d);
TimeSpan duration = new TimeSpan(d * m_totalTiles);
m_tileRuns.Clear();
m_lastUpdate = DateTime.Now;
DisplayProgress(sender, args);
}
}
private static void DisplayProgress(object sender, TileProgressEventArgs args)
{
if (hasConsole)
{
Console.Clear();
}
var map = args.Map;
var group = args.Group;
var scaleindex = args.ScaleIndex;
Console.WriteLine(string.Format(Strings.ConsoleUpdateTime.Replace("\\t", "\t"), DateTime.Now));
Console.WriteLine(string.Format(Strings.ConsoleCurrentMap.Replace("\\t", "\t"), map.ResourceId, mapCount, map.Parent.Maps.Count));
Console.WriteLine(string.Format(Strings.ConsoleCurrentGroup.Replace("\\t", "\t"), group, groupCount, map.TileSet.GroupCount));
Console.WriteLine(string.Format(Strings.ConsoleCurrentScale.Replace("\\t", "\t"), map.TileSet.GetScaleAt(Array.IndexOf <int>(map.ScaleIndexMap, scaleindex)), Array.IndexOf <int>(map.ScaleIndexMap, scaleindex) + 1, map.TileSet.ScaleCount));
Console.WriteLine(string.Format(Strings.ConsoleCurrentTile.Replace("\\t", "\t"), tileCount, totalTiles));
Console.WriteLine();
Console.WriteLine(string.Format(Strings.ConsoleGroupDuration.Replace("\\t", "\t"), DateTime.Now - beginGroup));
Console.WriteLine(string.Format(Strings.ConsoleGroupEstimate.Replace("\\t", "\t"), new TimeSpan(prevDuration.Ticks * totalTiles)));
if (exceptionList.Count != 0)
{
Console.WriteLine();
Console.WriteLine(string.Format(Strings.ConsoleErrorSummary, exceptionList.Count, exceptionList[exceptionList.Count - 1].ToString()));
}
}
private static void OnBeginRenderingScale(object sender, TileProgressEventArgs args)
{
beginScale = DateTime.Now;
if (m_loggableProgress)
{
Console.WriteLine(string.Format(Strings.ConsoleOperationBeginScale, beginMap, args.Map.TileSet.GetScaleAt(args.ScaleIndex), args.ScaleIndex, args.Map.Resolutions));
}
}
public void Test_TileEventArgs()
{
var mdfId = "Library://Samples/Sheboygan/MapsTiled/Sheboygan.MapDefinition";
var conn = new Mock <IServerConnection>();
var mockResSvc = new Mock <IResourceService>();
var mdf = ObjectFactory.CreateMapDefinition(new Version(1, 0, 0), "Sheboygan");
mdf.ResourceID = mdfId;
mdf.InitBaseMap();
var group = mdf.BaseMap.AddBaseLayerGroup("Base Layer Group");
group.Visible = true;
foreach (double scale in SCALE_LIST.Reverse())
{
mdf.BaseMap.AddFiniteDisplayScale(scale);
}
mdf.SetExtents(-87.764986990962839, 43.691398128787782, -87.695521510899724, 43.797520000480347);
mockResSvc.Setup(r => r.GetResource(It.Is <string>(arg => arg == mdfId))).Returns(mdf);
conn.Setup(c => c.ResourceService).Returns(mockResSvc.Object);
var tileRuns = new TilingRunCollection(conn.Object);
tileRuns.Config.DPI = 96;
tileRuns.Config.MetersPerUnit = 111319.490793274;
tileRuns.Config.RandomizeTileSequence = false;
tileRuns.Config.RetryCount = 5;
tileRuns.Config.ThreadCount = 1;
tileRuns.Config.TileWidth = 300;
tileRuns.Config.TileHeight = 300;
var tileConf = new MapTilingConfiguration(tileRuns, mdfId);
var tileRun = new TilingRunCollection(conn.Object);
var conf = new MapTilingConfiguration(tileRun, mdfId);
var args4 = new TileProgressEventArgs(CallbackStates.StartRenderTile, conf, "Base Layer Group", 1, 2, 3, false);
Assert.Equal(CallbackStates.StartRenderTile, args4.State);
Assert.Equal(conf, args4.Map);
Assert.Equal("Base Layer Group", args4.Group);
Assert.Equal(1, args4.ScaleIndex);
Assert.Equal(2, args4.Row);
Assert.Equal(3, args4.Column);
Assert.False(args4.Cancel);
var args5 = new TileRenderingErrorEventArgs(CallbackStates.StartRenderAllMaps, conf, "Base Layer Group", 1, 2, 3, new Exception("uh-oh"));
Assert.Equal(CallbackStates.StartRenderAllMaps, args5.State);
Assert.Equal(conf, args5.Map);
Assert.Equal("Base Layer Group", args5.Group);
Assert.Equal(1, args5.ScaleIndex);
Assert.Equal(2, args5.Row);
Assert.Equal(3, args5.Column);
Assert.NotNull(args5.Error);
Assert.Equal("uh-oh", args5.Error.Message);
}
private static void OnFinishRenderingGroup(object sender, TileProgressEventArgs args)
{
TimeSpan duration = DateTime.Now - beginGroup;
if (m_loggableProgress)
{
Console.WriteLine(string.Format(Strings.ConsoleOperationFinishGroup, DateTime.Now, args.Group, duration));
}
}
private static void OnBeginRenderingMap(object sender, TileProgressEventArgs args)
{
mapCount++;
beginMap = DateTime.Now;
if (m_loggableProgress)
{
Console.WriteLine(string.Format(Strings.ConsoleOperationBeginMap, beginMap, args.Map.ResourceId));
}
}
private static void OnFinishRenderingScale(object sender, TileProgressEventArgs args)
{
TimeSpan duration = DateTime.Now - beginScale;
if (m_loggableProgress)
{
Console.WriteLine(string.Format(Strings.ConsoleOperationFinishScale, DateTime.Now, args.Map.TileSet.GetScaleAt(args.ScaleIndex), duration));
}
}
private static void OnFinishRenderingMap(object sender, TileProgressEventArgs args)
{
groupCount = 0;
TimeSpan duration = DateTime.Now - beginMap;
if (m_loggableProgress)
{
Console.WriteLine(string.Format(Strings.ConsoleOperationFinishMap, DateTime.Now, args.Map.ResourceId, duration));
}
}
private void OnFinishRenderingMaps(object sender, TileProgressEventArgs args)
{
if (this.InvokeRequired)
{
this.Invoke(new System.Threading.ThreadStart(DoClose));
}
else
{
DoClose();
}
}
private static void OnBeginRenderingGroup(object sender, TileProgressEventArgs args)
{
groupCount++;
beginGroup = DateTime.Now;
if (m_loggableProgress)
{
Console.WriteLine(string.Format(Strings.ConsoleOperationBeginGroup, beginGroup, args.Group, 1, 1));
}
tileRuns = new List <TimeSpan>();
tileCount = 0;
totalTiles = args.Map.TotalTiles;
}
private void DisplayProgress(object sender, TileProgressEventArgs args)
{
if (m_cancel)
{
args.Cancel = true;
}
if (this.InvokeRequired)
{
TileProgressEventHandler action = DisplayProgress;
this.Invoke(action, new object[] { sender, args });
}
else
{
label1.Text = string.Format(Strings.CurrentGroupStatus, args.Group, args.Map.ResourceId);
tilePG.Value = (int)Math.Max(Math.Min((m_tileCount / (double)m_totalTiles) * (tilePG.Maximum - tilePG.Minimum), tilePG.Maximum), tilePG.Minimum);
totalPG.Value = (int)Math.Max(Math.Min((m_grandTotalTileCount / (double)m_grandTotalTiles) * (totalPG.Maximum - totalPG.Minimum), totalPG.Maximum), totalPG.Minimum);
var percentage = (int)(((double)m_grandTotalTileCount / (double)m_grandTotalTiles) * 100.0);
this.Text = $"{m_origTitle} - ({percentage}%)";
if (m_failCount == 0)
{
tileCounter.Text = string.Format(Strings.CurrentTileCounter, m_grandTotalTileCount, m_grandTotalTiles, string.Empty);
}
else
{
tileCounter.Text = string.Format(Strings.CurrentTileCounter, m_grandTotalTileCount, m_grandTotalTiles, string.Format(Strings.TileErrorCount, m_failCount));
}
TimeSpan elapsed = DateTime.Now - m_grandBegin;
DateTime finish = DateTime.Now + (new TimeSpan(m_prevDuration.Ticks * m_grandTotalTiles) - elapsed);
TimeSpan remain = finish - DateTime.Now;
if (finish < DateTime.Now)
{
finishEstimate.Text = Strings.InsufficientTimePassed;
}
else
{
finishEstimate.Text = string.Format(Strings.RemainingTime, finish.ToShortTimeString(), $"{Math.Floor(remain.TotalHours)}:{remain.Minutes.ToString("00")}:{remain.Seconds.ToString("00")}");
}
}
}
private static void OnFinishRenderingTile(object sender, TileProgressEventArgs args)
{
tileRuns.Add(DateTime.Now - beginTile);
tileCount++;
//Update display, after 1000 tiles
if (tileRuns.Count > 500 || (DateTime.Now - lastUpdate).TotalSeconds > 5)
{
long d = 0;
foreach (TimeSpan ts in tileRuns)
{
d += ts.Ticks;
}
d /= tileRuns.Count;
//For all other than the first calculation, we use the previous counts too
if (tileCount != tileRuns.Count)
{
d = (d + prevDuration.Ticks) / 2;
}
prevDuration = new TimeSpan(d);
TimeSpan duration = new TimeSpan(d * totalTiles);
tileRuns.Clear();
lastUpdate = DateTime.Now;
if (m_loggableProgress)
{
Console.WriteLine(string.Format(Strings.ConsoleOperationFinishTile, tileCount, totalTiles, args.Group, duration));
}
else
{
DisplayProgress(sender, args);
}
}
}
private void OnBeginRenderingMap(object sender, TileProgressEventArgs args) => m_tileCount = 0;
private void OnBeginRenderingGroup(object sender, TileProgressEventArgs args)
{
m_totalTiles = args.Map.TotalTiles;
m_tileCount = 0;
}
private void OnBeginRenderingScale(object sender, TileProgressEventArgs args)
{
}
private void OnBeginRenderingTile(object sender, TileProgressEventArgs args) => m_beginTile = DateTime.Now;
private static void OnBeginRenderingTile(object sender, TileProgressEventArgs args)
{
beginTile = DateTime.Now;
}
