public void AddToRetryList(MapTileIndex mapTileIndex)
{
lock (retryList)
{
retryList.Add(mapTileIndex);
}
}
public void AddToTaskList(MapTileIndex mapTileIndex)
{
lock (taskList)
{
taskList.Add(mapTileIndex);
}
}
public void ProcessTaskList()
{
while (!stopManager)
{
lock (taskList)
{
int count = Math.Min(taskList.Count, MAX_THREAD_NUM);
for (int i = 0; i < count; i++)
{
MapTileIndex mapTileIndex = GetOneTask();
MapTileDownloadWorker mapTileDownloadWorker = new MapTileDownloadWorker(this, mapTileIndex);
mapTileDownloadWorker.DownloadMapTile();
//Thread downloadThread = new Thread(new ThreadStart(mapTileDownloadWorker.DownloadMapTile));
//downloadThread.Start();
}
}
lock (retryList)
{
int count = Math.Min(retryList.Count, MAX_THREAD_NUM);
for (int i = 0; i < count; i++)
{
MapTileIndex mapTileIndex = GetOneTaskFromRetryList();
MapTileDownloadWorker mapTileDownloadWorker = new MapTileDownloadWorker(this, mapTileIndex);
mapTileDownloadWorker.DownloadMapTile();
//Thread downloadThread = new Thread(new ThreadStart(mapTileDownloadWorker.DownloadMapTile));
//downloadThread.Start();
}
}
}
}
public void AddToRetryList(MapTileIndex mapTileIndex)
{
lock (retryList)
{
retryList.Add(mapTileIndex);
}
}
public void AddToTaskList(MapTileIndex mapTileIndex)
{
lock(taskList)
{
taskList.Add(mapTileIndex);
}
}
public void AddToImageCache(MapTileIndex mapTileIndex,byte []imageData)
{
string mapIndex = mapTileIndex.MapType + "|" + mapTileIndex.XIndex + "|" +
mapTileIndex.YIndex + "|" + mapTileIndex.ZoomLevel;
lock (imageCache)
{
if(!imageCache.ContainsKey(mapIndex))
{
imageCache.Add(mapIndex,imageData);
}
}
}
public void RemoveFromImageCache(MapTileIndex mapTileIndex)
{
string mapIndex = mapTileIndex.MapType + "|" + mapTileIndex.XIndex + "|" +
mapTileIndex.YIndex + "|" + mapTileIndex.ZoomLevel;
lock (imageCache)
{
if (imageCache.ContainsKey(mapIndex))
{
imageCache.Remove(mapIndex);
}
}
}
public void AddToImageCache(MapTileIndex mapTileIndex, byte [] imageData)
{
string mapIndex = mapTileIndex.MapType + "|" + mapTileIndex.XIndex + "|" +
mapTileIndex.YIndex + "|" + mapTileIndex.ZoomLevel;
lock (imageCache)
{
if (!imageCache.ContainsKey(mapIndex))
{
imageCache.Add(mapIndex, imageData);
}
}
}
public byte[] GetFromImageCache(MapTileIndex mapTileIndex)
{
string mapIndex = mapTileIndex.MapType + "|" + mapTileIndex.XIndex + "|" +
mapTileIndex.YIndex + "|" + mapTileIndex.ZoomLevel;
lock (imageCache)
{
if (imageCache.ContainsKey(mapIndex))
{
return (byte[])imageCache[mapIndex];
}
}
return null;
}
public byte[] GetFromImageCache(MapTileIndex mapTileIndex)
{
string mapIndex = mapTileIndex.MapType + "|" + mapTileIndex.XIndex + "|" +
mapTileIndex.YIndex + "|" + mapTileIndex.ZoomLevel;
lock (imageCache)
{
if (imageCache.ContainsKey(mapIndex))
{
return((byte[])imageCache[mapIndex]);
}
}
return(null);
}
public MapTileIndex GetOneTask()
{
lock (taskList)
{
MapTileIndex mapTileIndex = null;
if (taskList.Count > 0)
{
mapTileIndex = taskList[0];
if (mapTileIndex != null)
{
taskList.Remove(mapTileIndex);
}
}
return(mapTileIndex);
}
}
public MapTileIndex GetOneTaskFromRetryList()
{
lock (retryList)
{
MapTileIndex mapTileIndex = null;
if (retryList.Count > 0)
{
mapTileIndex = retryList[retryList.Count - 1];
if (mapTileIndex != null)
{
retryList.Remove(mapTileIndex);
}
}
return(mapTileIndex);
}
}
//addDownloadTaskThread
private void AddDownloadTask()
{
try
{
int minX = int.Parse(txtStartX.Text) % 3;
int minY = int.Parse(txtStartY.Text) % 3;
int maxX = int.Parse(txtEndX.Text) % 3;
int maxY = int.Parse(txtEndY.Text) % 3;
int startX = Math.Min(minX, maxX);
int startY = Math.Min(minY, maxY);
int endX = Math.Max(minX, maxX);
int endY = Math.Max(minY, maxY);
for (int zoom = mapZoomLevel; zoom < 18; zoom++)
{
if (MapZoomLevelSelected[zoom])
{
int zoomPower = (int)Math.Pow(2, zoom - mapZoomLevel);
for (int indexX = startX * zoomPower; indexX < (endX + 1) * zoomPower; indexX++)
{
for (int indexY = startY * zoomPower; indexY < (endY + 1) * zoomPower; indexY++)
{
MapTileIndex mapTileIndex = new MapTileIndex();
mapTileIndex.MapType = mapType;
mapTileIndex.ZoomLevel = 17 - zoom;
mapTileIndex.XIndex = indexX + mapIndexX * zoomPower;
mapTileIndex.YIndex = indexY + mapIndexY * zoomPower;
mapTileDownloadManager.AddToTaskList(mapTileIndex);
Thread.Sleep(1000);
}
}
}
}
}
catch (Exception ex)
{
}
}
public void RemoveFromImageCache(MapTileIndex mapTileIndex)
{
string mapIndex = mapTileIndex.MapType + "|" + mapTileIndex.XIndex + "|" +
mapTileIndex.YIndex + "|" + mapTileIndex.ZoomLevel;
lock (imageCache)
{
if (imageCache.ContainsKey(mapIndex))
{
imageCache.Remove(mapIndex);
}
}
}
public MapTileDownloadWorker(MapTileDownloadManager mapTileDownloadManager, MapTileIndex mapTileIndex)
{
this.mapTileIndex = mapTileIndex;
this.mapTileDownloadManager = mapTileDownloadManager;
localMapTileFileReader = frmMain.localMapTileFileReader;
}
public void WriteMapTileFile()
{
string fileName = startIndexX + "_" + startIndexY + "_" + endIndexX + "_" + endIndexY + "_" + zoomLevel +
"_" + mapType + ".map";
if(File.Exists(fileName))
{
File.Delete(fileName);
}
FileStream mapFile = new FileStream(fileName, FileMode.CreateNew);
BinaryWriter writer = new BinaryWriter(mapFile);
JavaBinaryWriter javaWriter = new JavaBinaryWriter(writer);
int headSize = 256;
int levelSize = 1024;
int howManyTiles = CalculateHowManyTiles()+10;
int indexSize = howManyTiles * 8;
for (int i = 0; i <= headSize + levelSize + indexSize; i++)
javaWriter.Write((byte)0);
mapFile.Seek(0, SeekOrigin.Begin);
javaWriter.Write("GUIDEBEE MAP");
mapFile.Seek(16, SeekOrigin.Begin);
javaWriter.Write("JAVA");
mapFile.Seek(32, SeekOrigin.Begin);
javaWriter.Write("TILE");
mapFile.Seek(48, SeekOrigin.Begin);
javaWriter.Write((int)mapType); //PNG type
int zoomCount = 0;
for (int zoom = zoomLevel; zoom < 18; zoom++)
{
if (zoomLevelSelected[zoom])
{
zoomCount++;
}
}
javaWriter.Write((int)zoomCount);
javaWriter.Write((double)-90.0);
javaWriter.Write((double)-180.0);
javaWriter.Write((double)90.0);
javaWriter.Write((double)180.0);
mapFile.Seek(256, SeekOrigin.Begin);
int levelOffset = headSize + levelSize;
int pngOffset = headSize + levelSize + indexSize;
zoomCount = 0;
int imageIndex = 0;
for (int zoom = zoomLevel; zoom < 18; zoom++)
{
if (zoomLevelSelected[zoom])
{
int zoomPower = (int)Math.Pow(2, zoom - zoomLevel);
int levelLength = 0;
int pngLenght = 0;
for (int i = startIndexX * zoomPower; i < (endIndexX + 1) * zoomPower; i++)
{
for (int j = startIndexY * zoomPower; j < (endIndexY + 1) * zoomPower; j++)
{
MapTileIndex mapTileIndex=new MapTileIndex();
mapTileIndex.MapType = mapType;
mapTileIndex.ZoomLevel = 17 - zoom;
mapTileIndex.XIndex = i;
mapTileIndex.YIndex = j ;
byte[] pngImage = mapTileDownloadManager.GetFromImageCache(mapTileIndex);
int tryCount = 0;
while (pngImage==null && tryCount<3)
{
Thread.Sleep(30000);
pngImage = mapTileDownloadManager.GetFromImageCache(mapTileIndex);
tryCount++;
}
if(pngImage==null)
{
pngImage = notavaiablePng;
}else
{
mapTileDownloadManager.RemoveFromImageCache(mapTileIndex);
}
pngLenght = pngImage.Length;
mapFile.Seek(headSize + levelSize + imageIndex*8
, SeekOrigin.Begin);
javaWriter.Write(pngOffset);
javaWriter.Write(pngLenght);
mapFile.Seek(pngOffset
, SeekOrigin.Begin);
writer.Write(pngImage);
pngOffset += pngLenght;
imageIndex++;
}
}
levelLength = (endIndexX + 1 - startIndexX) * (endIndexY + 1 - startIndexY) * zoomPower * zoomPower * 8;
//write level offset
mapFile.Seek(headSize + zoomCount * 28
, SeekOrigin.Begin);
javaWriter.Write(zoom);
javaWriter.Write((int)startIndexX * zoomPower);
javaWriter.Write((int)startIndexY * zoomPower);
javaWriter.Write((endIndexX + 1) * zoomPower - 1);
javaWriter.Write((endIndexY + 1) * zoomPower - 1);
javaWriter.Write(levelOffset);
javaWriter.Write(levelLength);
levelOffset += levelLength;
zoomCount++;
}
}
javaWriter.Close();
mapFile.Close();
mapTileDownloadManager.Done();
}
