private PureImage GetTileImage(GPoint pos, int zoom, Size tileSize)
{
var tileCenterLatLng = TileToWorldPos(pos.X + 0.5, pos.Y + 0.5, zoom);
var map = new StaticMapRequest
{
Center = new Location(tileCenterLatLng.Lat + "," + tileCenterLatLng.Lng),
MapType = _mapType,
Size = tileSize,
Zoom = zoom,
Sensor = false
};
var imageUri = map.ToUri().ToString();
if (GoogleSigned.SigningInstance != null)
{
imageUri = GoogleSigned.SigningInstance.GetSignedUri(imageUri);
}
PureImage image = null;
try
{
image = GetTileImageUsingHttp(imageUri);
}
catch (WebException e)
{
// WebException such as 404 / Forbidden etc.
Debug.WriteLine(e.Message);
}
return(image);
}
public override bool Save(Stream stream, PureImage image)
{
WindowsFormsImage ret = image as WindowsFormsImage;
bool ok = true;
if (ret.Img != null)
{
// try png
try
{
ret.Img.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
}
catch
{
// try jpeg
try
{
stream.Seek(0, SeekOrigin.Begin);
ret.Img.Save(stream, System.Drawing.Imaging.ImageFormat.Jpeg);
}
catch
{
ok = false;
}
}
}
else
{
ok = false;
}
return(ok);
}
public PureImage GetTileImageUsingHttp(string url)
{
PureImage ret = null;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
if (WebProxy != null)
{
request.Proxy = WebProxy;
}
#if !PocketPC
if (Credential != null)
{
request.PreAuthenticate = true;
request.Credentials = Credential;
}
#endif
request.UserAgent = UserAgent;
request.Timeout = TimeoutMs;
request.ReadWriteTimeout = TimeoutMs * 6;
request.Accept = requestAccept;
if (!string.IsNullOrEmpty(RefererUrl))
{
request.Referer = RefererUrl;
}
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
//if(response.StatusCode == HttpStatusCode.OK)
{
MemoryStream responseStream = Stuff.CopyStream(response.GetResponseStream(), false);
{
Debug.WriteLine("Response[" + responseStream.Length + " bytes]" + url);
if (responseStream.Length > 0)
{
ret = TileImageProxy.FromStream(responseStream);
}
if (ret != null)
{
ret.Data = responseStream;
ret.Data.Position = 0;
}
else
{
responseStream.Dispose();
}
}
responseStream = null;
}
#if PocketPC
request.Abort();
#endif
response.Close();
}
return(ret);
}
private PureImage GetTileImageWithoutBranding(GPoint pos, int zoom)
{
PureImage cleanTile = null;
const int brandingHeight = 25;
// we fetch a tile which is 25px bigger at the top as well as at the bottom
var brandedTile = GetTileImage(pos, zoom, new Size(
DefaultTileSize.Width,
DefaultTileSize.Height + brandingHeight * 2));
// now we cut away the additional 25px at the upper and lower border
// this will automatically also cut away the branding / copyright of the tile
if (brandedTile != null)
{
using (brandedTile)
using (var tempBitmap = new Bitmap(brandedTile.Data))
using (var cropped = CropImage(tempBitmap, new Rectangle(
0, // x
brandingHeight, // y
DefaultTileSize.Width, // width
DefaultTileSize.Height))) // height
{
var memoryStream = new MemoryStream();
cropped.Save(memoryStream, ImageFormat.Png);
memoryStream.Position = 0;
cleanTile = TileImageProxy.FromStream(memoryStream);
cleanTile.Data = memoryStream;
}
}
return(cleanTile);
}
private void WriteTileToDisk(PureImage img, int zoom, GPoint p)
{
DirectoryInfo di = new DirectoryInfo(tilePath + "/_alllayers");
string zoomStr = string.Format("{0:D2}", zoom);
long x = p.X;
long y = p.Y;
string col = string.Format("{0:x8}", x).ToLower();
string row = string.Format("{0:x8}", y).ToLower();
string dir = di.FullName + "/L" + zoomStr + "/R" + row + "//";
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
FileStream fs = new FileStream(dir + "C" + col + ".png", FileMode.Create, FileAccess.Write);
BinaryWriter sw = new BinaryWriter(fs);
//读出图片字节数组至byte[]
byte[] imageByte = img.Data.ToArray();
sw.Write(imageByte);
sw.Close();
fs.Close();
}
PureImage PureImageCache.GetImageFromCache(MapType type, GPoint pos, int zoom)
{
PureImage ret = null;
try
{
string file = CacheLocation + Path.DirectorySeparatorChar + type.ToString() + Path.DirectorySeparatorChar + zoom + Path.DirectorySeparatorChar + pos.Y + Path.DirectorySeparatorChar + pos.X + ".jpg";
if (File.Exists(file))
{
BinaryReader sr = new BinaryReader(File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read));
{
byte[] tile = sr.ReadBytes((int)sr.BaseStream.Length);
MemoryStream stm = new MemoryStream(tile, 0, tile.Length, false, true);
ret = GMaps.Instance.ImageProxy.FromStream(stm);
if (ret != null)
{
ret.Data = stm;
}
}
}
}
catch (Exception ex)
{
#if MONO
Console.WriteLine("GetImageFromCache: " + ex.ToString());
#endif
Debug.WriteLine("GetImageFromCache: " + ex.ToString());
ret = null;
}
return(ret);
}
internal void AddOverlay(PureImage i)
{
if (overlays == null)
{
// overlays = new PureImage[4];
//VH Map
overlays = new PureImage[8];
}
#if !PocketPC
//Orig overlays[Interlocked.Increment(ref OverlaysCount) - 1] = i;
//VH Map
long index = Interlocked.Increment(ref OverlaysCount) - 1;
if (index < overlays.Length)
{
overlays[index] = i;
}
else
{
//VH Map
Interlocked.Decrement(ref OverlaysCount);
}
#else
overlays[++OverlaysCount - 1] = i;
#endif
}
private string BuildTileExportPath(PureImage img, int zoom, GPoint p)
{
string tileSuffix = "png";
if (this.exportParameter.ExportType == ExportType.ArcGISTile)
{
DirectoryInfo dir = new DirectoryInfo(exportParameter.ExportPath + "/Layer/_alllayers");
string zoomStr = string.Format("{0:D2}", zoom);
long x = p.X;
long y = p.Y;
string col = string.Format("{0:x8}", x).ToLower();
string row = string.Format("{0:x8}", y).ToLower();
string pathDir = dir.FullName + "/" + "L" + zoomStr + "/" + "R" + row + "/";
string path = pathDir + "C" + col + "." + tileSuffix;
return(path);
}
if ((this.exportParameter.ExportType == ExportType.TMSTile) || (this.exportParameter.ExportType == ExportType.BaiduTile))
{
RectifyBaiduOrTMSTile(img, zoom, p);
}
if (exportParameter.ExportType == ExportType.DefaultYXTile)
{
return(string.Format("{0}/{1}/{2}/{3}/{4}.{5}", new object[] { this.exportParameter.ExportPath, "tiles", zoom, p.Y, p.X, tileSuffix }));
}
return(string.Format("{0}/{1}/{2}/{3}/{4}.{5}", new object[] { this.exportParameter.ExportPath, "tiles", zoom, p.X, p.Y, tileSuffix }));
}
public void RectifyBaiduOrTMSTile(PureImage img, int zoom, GPoint p)
{
long y = this.mapProvider.Projection.FromLatLngToTileXY(this.mapProvider.Projection.Bounds.Top, this.mapProvider.Projection.Bounds.Left, zoom).Y;
long y0 = this.mapProvider.Projection.FromLatLngToTileXY(this.mapProvider.Projection.Bounds.Bottom, this.mapProvider.Projection.Bounds.Right, zoom).Y;
if (this.exportParameter.ExportType == ExportType.TMSTile)
{
long p_y = (y + y0) - p.Y;
p.Y = p_y;
}
else if (this.exportParameter.ExportType == ExportType.BaiduTile)
{
long p_x;
long p_y;
long x = this.mapProvider.Projection.FromLatLngToTileXY(this.mapProvider.Projection.Bounds.LocationTopLeft, zoom).X;
long x0 = this.mapProvider.Projection.FromLatLngToTileXY(this.mapProvider.Projection.Bounds.LocationRightBottom, zoom).X;
if (this.mapProvider is BaiduMapProviderBase)
{
int num = Convert.ToInt32(Math.Pow(2.0, (double)(zoom - 1)));
p_x = p.X - num;
p_y = (num - p.Y) - 1;
}
else
{
long delta_x = (x0 - y) + 1;
long delta_y = (y0 - y) + 1;
p_x = p.X - (delta_x / 2);
p_y = (p.Y + 1) - (delta_y / 2);
}
p.X = p_x;
p.Y = p_y;
}
}
public override bool Save(System.IO.Stream stream, PureImage image)
{
GMapImage ret = (GMapImage)image;
if (ret.Img != null)
{
try
{
PngBitmapEncoder e = new PngBitmapEncoder();
e.Frames.Add(BitmapFrame.Create(ret.Img as BitmapSource));
e.Save(stream);
e = null;
}
catch
{
return(false);
}
}
else
{
return(false);
}
return(true);
}
void IMapControl.DrawTile(object go, PureImage pureImage, ref bool found)
{
Graphics g = (Graphics)go;
var img = (GMapImage)pureImage;
if (img != null && img.Img != null)
{
if (!found)
{
found = true;
}
if (!img.IsParent)
{
g.DrawImage(img.Img, fCore.TileRect.X, fCore.TileRect.Y, fCore.TileRect.Width, fCore.TileRect.Height);
}
else
{
float wix = ((float)img.Img.Width / img.Ix);
float hix = ((float)img.Img.Height / img.Ix);
RectangleF srcRect = new RectangleF(img.Xoff * wix, img.Yoff * hix, wix, hix);
Rectangle dst = new Rectangle((int)fCore.TileRect.X, (int)fCore.TileRect.Y, (int)fCore.TileRect.Width, (int)fCore.TileRect.Height);
g.DrawImage(img.Img, dst, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, GraphicsUnit.Pixel, TileFlipXYAttributes);
}
}
}
internal void AddOverlay(PureImage i)
{
if (overlays == null)
{
// overlays = new PureImage[4];
//VH Map
overlays = new PureImage[8];
}
#if !PocketPC
//Orig overlays[Interlocked.Increment(ref OverlaysCount) - 1] = i;
//VH Map
long index = Interlocked.Increment(ref OverlaysCount) - 1;
if (index < overlays.Length)
{
overlays[index] = i;
}
else
{
//VH Map
Interlocked.Decrement(ref OverlaysCount);
}
#else
overlays[++OverlaysCount - 1] = i;
#endif
}
protected PureImage GetTileImageUsingHttp(string url)
{
PureImage ret = null;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
if (WebProxy != null)
{
request.Proxy = WebProxy;
}
if (Credential != null)
{
request.PreAuthenticate = true;
request.Credentials = Credential;
}
request.UserAgent = UserAgent;
request.Timeout = TimeoutMs;
request.ReadWriteTimeout = TimeoutMs * 6;
request.Accept = requestAccept;
request.Referer = RefererUrl;
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
if (CheckTileImageHttpResponse(response))
{
MemoryStream responseStream = Stuff.CopyStream(response.GetResponseStream(), false);
{
Console.WriteLine("Response[" + responseStream.Length + " bytes]: " + url);
if (responseStream.Length > 0)
{
ret = TileImageProxy.FromStream(responseStream);
}
if (ret != null)
{
ret.Data = responseStream;
ret.Data.Position = 0;
}
else
{
responseStream.Dispose();
}
}
responseStream = null;
}
else
{
Debug.WriteLine("CheckTileImageHttpResponse[false]: " + url);
}
#if PocketPC
request.Abort();
#endif
response.Close();
}
return(ret);
}
internal void AddOverlay(PureImage i)
{
if (overlays == null)
{
overlays = new PureImage[4];
}
overlays[Interlocked.Increment(ref OverlaysCount) - 1] = i;
}
PureImage IPureImageCache.GetImageFromCache(int type, GPoint pos, int zoom)
{
PureImage ret = null;
try {
using (SQLiteConnection cn = new SQLiteConnection()) {
cn.ConnectionString = fConnectionString;
cn.Open();
if (!string.IsNullOrEmpty(fAttachSqlQuery))
{
using (DbCommand com = cn.CreateCommand()) {
com.CommandText = fAttachSqlQuery;
int x = com.ExecuteNonQuery();
//Debug.WriteLine("Attach: " + x);
}
}
using (DbCommand com = cn.CreateCommand()) {
com.CommandText = string.Format(fFinalSqlSelect, pos.X, pos.Y, zoom, type);
using (DbDataReader rd = com.ExecuteReader(System.Data.CommandBehavior.SequentialAccess)) {
if (rd.Read())
{
long length = rd.GetBytes(0, 0, null, 0, 0);
byte[] tile = new byte[length];
rd.GetBytes(0, 0, tile, 0, tile.Length);
if (GMaps.TileImageProxy != null)
{
ret = GMaps.TileImageProxy.FromArray(tile);
}
}
rd.Close();
}
}
if (!string.IsNullOrEmpty(fDetachSqlQuery))
{
using (DbCommand com = cn.CreateCommand()) {
com.CommandText = fDetachSqlQuery;
int x = com.ExecuteNonQuery();
//Debug.WriteLine("Detach: " + x);
}
}
cn.Close();
}
} catch (Exception ex) {
#if MONO
Console.WriteLine("GetImageFromCache: " + ex.ToString());
#endif
Debug.WriteLine("GetImageFromCache: " + ex);
ret = null;
}
return(ret);
}
public PureImage GetImageFromCache(MapType type, Point pos, int zoom)
{
PureImage ret = null;
{
if (Initialize())
{
try
{
object odata = null;
lock (cmdFetch)
{
cnGet.Ping();
if (cnGet.State != ConnectionState.Open)
{
cnGet.Open();
}
cmdFetch.Parameters["@type"].Value = (int)type;
cmdFetch.Parameters["@zoom"].Value = zoom;
cmdFetch.Parameters["@x"].Value = pos.X;
cmdFetch.Parameters["@y"].Value = pos.Y;
odata = cmdFetch.ExecuteScalar();
}
if (odata != null && odata != DBNull.Value)
{
byte[] tile = (byte[])odata;
if (tile != null && tile.Length > 0)
{
if (GMaps.Instance.ImageProxy != null)
{
MemoryStream stm = new MemoryStream(tile, 0, tile.Length, false, true);
ret = GMaps.Instance.ImageProxy.FromStream(stm);
if (ret != null)
{
ret.Data = stm;
}
}
}
tile = null;
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
ret = null;
Dispose();
}
}
}
return(ret);
}
public PureImage GetImageFromCache(int type, GPoint pos, int zoom)
{
PureImage ret = null;
{
if (Initialize())
{
try
{
object odata = null;
using (MySqlConnection cnGet = new MySqlConnection(connectionString))
{
cnGet.Open();
using (
MySqlCommand cmdFetch =
new MySqlCommand(
"SELECT Tile FROM `gmapnetcache` WHERE Type=@type AND Zoom=@zoom AND X=@x AND Y=@y",
cnGet))
{
cmdFetch.Parameters.Add("@type", MySqlDbType.Int32);
cmdFetch.Parameters.Add("@zoom", MySqlDbType.Int32);
cmdFetch.Parameters.Add("@x", MySqlDbType.Int32);
cmdFetch.Parameters.Add("@y", MySqlDbType.Int32);
cmdFetch.Prepare();
cmdFetch.Parameters["@type"].Value = type;
cmdFetch.Parameters["@zoom"].Value = zoom;
cmdFetch.Parameters["@x"].Value = pos.X;
cmdFetch.Parameters["@y"].Value = pos.Y;
odata = cmdFetch.ExecuteScalar();
}
}
if (odata != null && odata != DBNull.Value)
{
byte[] tile = (byte[])odata;
if (tile != null && tile.Length > 0)
{
if (GMapProvider.TileImageProxy != null)
{
ret = GMapProvider.TileImageProxy.FromArray(tile);
}
}
tile = null;
}
}
catch (Exception ex)
{
Debug.WriteLine("MySQL GetImageFromCache: " + ex.ToString());
ret = null;
//Dispose();
}
}
}
return(ret);
}
PureImage PureImageCache.GetImageFromCache(MapType type, Point pos, int zoom)
{
PureImage ret = null;
try
{
using (SQLiteConnection cn = new SQLiteConnection())
{
cn.ConnectionString = ConnectionString;
cn.Open();
{
using (DbCommand com = cn.CreateCommand())
{
com.CommandText = string.Format(sqlSelect, pos.X, pos.Y, zoom, (int)type);
using (DbDataReader rd = com.ExecuteReader(System.Data.CommandBehavior.SequentialAccess))
{
if (rd.Read())
{
long length = rd.GetBytes(0, 0, null, 0, 0);
byte[] tile = new byte[length];
rd.GetBytes(0, 0, tile, 0, tile.Length);
{
if (GMaps.Instance.ImageProxy != null)
{
MemoryStream stm = new MemoryStream(tile, 0, tile.Length, false, true);
ret = GMaps.Instance.ImageProxy.FromStream(stm);
if (ret != null)
{
ret.Data = stm;
}
}
}
tile = null;
}
rd.Close();
}
}
}
cn.Close();
}
}
catch (Exception ex)
{
#if MONO
Console.WriteLine("GetImageFromCache: " + ex.ToString());
#endif
Debug.WriteLine("GetImageFromCache: " + ex.ToString());
ret = null;
}
return(ret);
}
internal void AddOverlay(PureImage i)
{
if (overlays == null)
{
overlays = new PureImage[4];
}
#if !PocketPC
overlays[Interlocked.Increment(ref OverlaysCount) - 1] = i;
#else
overlays[++OverlaysCount - 1] = i;
#endif
}
private PureImage GetTileImageUsingHttp(string url)
{
PureImage ret = null;
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
request.UserAgent = UserAgent;
request.ReadWriteTimeout = TimeoutMs * 6;
request.Accept = requestAccept;
request.Referer = RefererUrl;
request.Timeout = TimeoutMs;
try
{
using (var response = request.GetResponse())
{
if (response.ContentType.Contains("image"))
{
using (Stream responseStream = response.GetResponseStream())
{
MemoryStream data = Stuff.CopyStream(responseStream, false);
Debug.WriteLine("Response[" + data.Length + " bytes]: " + url);
if (data.Length > 0)
{
ret = GMapProvider.TileImageProxy.FromArray(data.GetBuffer());
if (ret != null)
{
ret.Data = data;
ret.Data.Position = 0;
}
else
{
data.Dispose();
}
}
}
}
else
{
Debug.WriteLine("CheckTileImageHttpResponse[false]: " + url);
}
response.Close();
}
}
catch (Exception ex)
{
Debug.WriteLine("GetTileImageUsingHttp: {0}, {1}", url, ex);
}
return(ret);
}
internal void AddOverlay(PureImage i)
{
if (_overlays == null)
{
_overlays = new PureImage[4];
}
#if !PocketPC
_overlays[Interlocked.Increment(ref _overlaysCount) - 1] = i;
#else
overlays[++OverlaysCount - 1] = i;
#endif
}
protected PureImage GetTileImageUsingHttp(string url)
{
PureImage ret = null;
HttpClient client = new HttpClient();
if (!string.IsNullOrEmpty(UserAgent))
{
client.DefaultRequestHeaders.Add("User-Agent", UserAgent);
}
if (!string.IsNullOrEmpty(requestAccept))
{
client.DefaultRequestHeaders.Add("Accept", requestAccept);
}
if (!string.IsNullOrEmpty(RefererUrl))
{
client.DefaultRequestHeaders.Add("Referer", RefererUrl);
}
MemoryStream data = Task.Run(async() =>
{
using (var response = await client.GetAsync(url))
{
if (response.IsSuccessStatusCode)
{
var stream = await response.Content.ReadAsStreamAsync();
return(Stuff.CopyStream(stream, false));
}
throw new WebException((int)response.StatusCode + " " + response.ReasonPhrase);
}
}).GetAwaiter().GetResult();
Debug.WriteLine("Response[" + data.Length + " bytes]: " + url);
if (data.Length > 0)
{
ret = TileImageProxy.FromStream(data);
if (ret != null)
{
ret.Data = data;
ret.Data.Position = 0;
}
else
{
data.Dispose();
}
}
data = null;
return(ret);
}
public PureImage GetImageFromCache(int type, GPoint pos, int zoom)
{
if (string.IsNullOrEmpty(ConnectionString))
{
return(null);
}
PureImage ret = null;
try
{
using (SQLiteConnection cn = new SQLiteConnection())
{
cn.ConnectionString = ConnectionString;
cn.Open();
using (DbCommand com = cn.CreateCommand())
{
com.CommandText = string.Format(finnalSqlSelect, pos.X, pos.Y, zoom);
using (DbDataReader rd = com.ExecuteReader(System.Data.CommandBehavior.SequentialAccess))
{
if (rd.Read())
{
long length = rd.GetBytes(0, 0, null, 0, 0);
byte[] tile = new byte[length];
rd.GetBytes(0, 0, tile, 0, tile.Length);
{
if (GMapProvider.TileImageProxy != null)
{
ret = GMapProvider.TileImageProxy.FromArray(tile);
}
}
tile = null;
}
rd.Close();
}
}
cn.Close();
}
}
catch (Exception ex)
{
#if MONO
Console.WriteLine("GetImageFromCache: " + ex.ToString());
#endif
Debug.WriteLine("GetImageFromCache: " + ex.ToString());
ret = null;
}
return(ret);
}
public PureImage GetImageFromCache(int type, GPoint pos, int zoom)
{
PureImage ret = null;
{
if (Initialize())
{
try
{
object odata = null;
lock (cmdFetch)
{
cnGet.Ping();
if (cnGet.State != ConnectionState.Open)
{
cnGet.Open();
}
cmdFetch.Parameters["@type"].Value = type;
cmdFetch.Parameters["@zoom"].Value = zoom;
cmdFetch.Parameters["@x"].Value = pos.X;
cmdFetch.Parameters["@y"].Value = pos.Y;
odata = cmdFetch.ExecuteScalar();
}
if (odata != null && odata != DBNull.Value)
{
byte[] tile = (byte[])odata;
if (tile != null && tile.Length > 0)
{
if (GMapProvider.TileImageProxy != null)
{
ret = GMapProvider.TileImageProxy.FromArray(tile);
}
}
tile = null;
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
ret = null;
Dispose();
}
}
}
return(ret);
}
public override PureImage GetTileImage(GPoint pos, int zoom)
{
try
{
string str = "cva_w";
int serverIndex = GMapProvider.GetServerNum(pos, TiandituProviderBase.maxServer);
//string url = string.Format(TiandituProviderBase.UrlFormat, new object[] { serverIndex, str, str.Substring(0, str.Length - 2), str.Substring(str.Length - 1), zoom, pos.Y, pos.X });
string url = string.Format(TiandituProviderBase.UrlFormat, new object[] { serverIndex, str, pos.X, pos.Y, zoom });
PureImage ret = base.GetTileImageUsingHttp(url);
return(ret);
}
catch (Exception ex)
{
return(null);
}
}
public PureImage GetRasterImage(Point position, int zoom)
{
int x = position.X;
int y = position.Y;
string file = string.Format(_fomattedPath, zoom, y, x);
if (File.Exists(file))
{
Stream stream = new StreamReader(file).BaseStream;
PureImage img = GMaps.Instance.ImageProxy.FromStream(stream);
stream.Close();
return(img);
}
return(null);
}
private void WriteGeoFileToDisk(PureImage img, int zoom, GPoint p)
{
DirectoryInfo dir = new DirectoryInfo(tilePath + "//Layer//_alllayers");
FileStream fs = new FileStream(dir + "//" + p.Y.ToString() + p.X.ToString() + ".jgw", FileMode.Create, FileAccess.Write);
StreamWriter sw = new StreamWriter(fs);
double[] ret = GetCoordinatesFromAddress(p.Y, p.X, zoom);
sw.WriteLine(ret[0].ToString("0.0000000000"));
sw.WriteLine("0.0000000000");
sw.WriteLine("0.0000000000");
sw.WriteLine(ret[1].ToString("0.0000000000"));
sw.WriteLine(ret[2].ToString("0.0000000000"));
sw.WriteLine(ret[3].ToString("0.0000000000"));
sw.Close();
fs.Close();
}
private void WriteTileToDisk(PureImage img, int zoom, GPoint p)
{
string path = BuildTileExportPath(img, zoom, p);
string pathDir = path.Substring(0, path.LastIndexOf('/'));
if (!Directory.Exists(pathDir))
{
Directory.CreateDirectory(pathDir);
}
FileStream fs = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write);
BinaryWriter sw = new BinaryWriter(fs);
//读出图片字节数组至byte[]
byte[] imageByte = img.Data.ToArray();
sw.Write(imageByte);
sw.Close();
fs.Close();
}
protected PureImage GetTileImageUsingHttp(string url)
{
PureImage ret = null;
HttpClient client = new HttpClient();
if (!string.IsNullOrEmpty(UserAgent))
{
client.DefaultRequestHeaders.Add("User-Agent", UserAgent);
}
if (!string.IsNullOrEmpty(requestAccept))
{
client.DefaultRequestHeaders.Add("Accept", requestAccept);
}
if (!string.IsNullOrEmpty(RefererUrl))
{
client.DefaultRequestHeaders.Add("Referer", RefererUrl);
}
MemoryStream data = Task.Run(async() =>
{
return(Stuff.CopyStream(await client.GetStreamAsync(url), false));
}).Result;
Debug.WriteLine("Response[" + data.Length + " bytes]: " + url);
if (data.Length > 0)
{
ret = TileImageProxy.FromStream(data);
if (ret != null)
{
ret.Data = data;
ret.Data.Position = 0;
}
else
{
data.Dispose();
}
}
data = null;
return(ret);
}
public PureImage GetImageFromCache(int type, GPoint pos, int zoom)
{
PureImage ret = null;
{
if (Initialize())
{
try
{
object odata = null;
lock (cmdFetch)
{
cmdFetch.Parameters["@x"].Value = pos.X;
cmdFetch.Parameters["@y"].Value = pos.Y;
cmdFetch.Parameters["@zoom"].Value = zoom;
cmdFetch.Parameters["@type"].Value = type;
odata = cmdFetch.ExecuteScalar();
}
if (odata != null && odata != DBNull.Value)
{
byte[] tile = (byte[])odata;
if (tile != null && tile.Length > 0)
{
if (GMapProvider.TileImageProxy != null)
{
ret = GMapProvider.TileImageProxy.FromArray(tile);
}
}
tile = null;
}
}
catch
{
ret = null;
Dispose();
}
}
}
return(ret);
}
public PureImage GetTileImageUsingHttp(string url)
{
PureImage ret = null;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
if (WebProxy != null)
{
request.Proxy = WebProxy;
#if !PocketPC
request.PreAuthenticate = true;
#endif
}
request.UserAgent = UserAgent;
request.Timeout = TimeoutMs;
request.ReadWriteTimeout = TimeoutMs * 6;
request.Accept = requestAccept;
if (!string.IsNullOrEmpty(RefererUrl))
{
request.Referer = RefererUrl;
}
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
MemoryStream responseStream = Stuff.CopyStream(response.GetResponseStream(), false);
{
Debug.WriteLine("Response: " + url);
ret = TileImageProxy.FromStream(responseStream);
if (ret != null)
{
ret.Data = responseStream;
}
}
#if PocketPC
request.Abort();
#endif
response.Close();
}
return(ret);
}
public PureImage ReadImageFile(GPoint pos, int zoom)
{
string tile_file = string.Format(tile_file_path, zoom, pos.X, pos.Y);
if (!File.Exists(tile_file))
{
return(null);//文件不存在
}
//FileStream fs = File.OpenRead(tile_file); //OpenRead
byte[] data = File.ReadAllBytes(tile_file);
MemoryStream ms = new MemoryStream(data);
//int filelength = 0;
//filelength = (int)fs.Length; //获得文件长度
//Byte[] image = new Byte[filelength]; //建立一个字节数组
//fs.Read(image, 0, filelength); //按字节流读取
PureImage ret = GMapProvider.TileImageProxy.FromStream(ms);
if (ms.Length > 0)
{
ret = TileImageProxy.FromStream(ms);
if (ret != null)
{
ret.Data = ms;
ret.Data.Position = 0;
}
else
{
ms.Dispose();
}
}
ms = null;
//fs.Close();
return(ret);
//Bitmap bit = new Bitmap(result);
//return bit;
}
public override bool Save(Stream stream, PureImage image)
{
WindowsFormsImage ret = image as WindowsFormsImage;
bool ok = true;
if(ret.Img != null)
{
// try png
try
{
ret.Img.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
}
catch
{
// try jpeg
try
{
stream.Seek(0, SeekOrigin.Begin);
ret.Img.Save(stream, System.Drawing.Imaging.ImageFormat.Jpeg);
}
catch
{
ok = false;
}
}
}
else
{
ok = false;
}
return ok;
}
internal void AddOverlay(PureImage i)
{
if(overlays == null)
{
overlays = new PureImage[4];
}
overlays[Interlocked.Increment(ref OverlaysCount) - 1] = i;
}
public override bool Save(System.IO.Stream stream, PureImage image)
{
WindowsPresentationImage ret = (WindowsPresentationImage) image;
if(ret.Img != null)
{
try
{
PngBitmapEncoder e = new PngBitmapEncoder();
e.Frames.Add(BitmapFrame.Create(ret.Img as BitmapSource));
e.Save(stream);
}
catch
{
return false;
}
}
else
{
return false;
}
return true;
}
