google map super map

Google地图瓦片缓存机制
本文介绍了一个基于C#实现的Google地图瓦片缓存处理程序,该程序能够根据请求参数从Google地图服务器获取地图瓦片,并进行本地缓存。通过对地图比例尺的计算,确定请求的图幅范围及分辨率,进而决定是否从远程获取瓦片或将已缓存的瓦片返回给客户端。
<%@ WebHandler Language="C#" Class="GoogleMap" %>

using System;
using System.Web;
using SuperMap.IS.Web;
using SuperMap.IS.Utility;
using System.IO;
using System.Net;
using System.Globalization;
using System.Drawing;
using System.Text;
using System.Collections.Generic;


public class GoogleMap : IHttpHandler
{
    private Dictionary<string, string> Uris = new Dictionary<string, string>();
    private const string MapTileUri = "http://mt{0}.google.cn/vt/lyrs=m@127&hl=zh-CN&gl=cn&src=api&x={1}&y={2}&z={3}&s=Gal";
    private const string SatelliteTileUri = "http://mt{0}.google.cn/vt/lyrs=s@63&gl=cn&x={1}&s=&y={2}&z={3}&s=Gal";
    private string OutPutPath = @"E:\Program Files\SuperMap\SuperMap IS .NET 6\output";   
    private double tileBaseWidth = 400750166.6855785;
    private double tileBaseHeight = 39858478.2258614;
    private string mapType = "Satellite";
    public void ProcessRequest(HttpContext context)
    {
        Uris.Add("Map", MapTileUri);
        Uris.Add("Satellite", SatelliteTileUri);
        //索引
        string tx = context.Request["tx"];
        string ty = context.Request["ty"];
        string msstr = context.Request["ms"];
        string _mapType = context.Request["type"];
        //string offsetX = context.Request["offsetX"];
        //string offsetY = context.Request["offsetY"];
        if (_mapType != null) { mapType = _mapType; }
        int ms = (int)(1 / Double.Parse(msstr));
        //当前请求图幅范围
        MapRect viewBounds = new MapRect(Convert.ToDouble(context.Request["lbx"]), Convert.ToDouble(context.Request["lby"]), Convert.ToDouble(context.Request["rtx"]), Convert.ToDouble(context.Request["rty"]));
        //当前请求图幅比例尺       
        int z = GetZoomLevel(viewBounds.Width, viewBounds.Height);
        //缓存图片名称
        string imgName = "gm_" + tx + "_" + ty + "_" + ms.ToString() + ".png";
        //GoogleMap缓存目录
        string fPath = OutPutPath + @"\GoogleMapCache";
        //地图类别目录
        string fyPath = fPath + @"\" + mapType;
        //GoogleMap分级目录
        string zfPath = fyPath + @"\" + ms.ToString();
        //GoogleMap缓存全路径
        string fullPath = zfPath + @"\" + imgName;
        Bitmap returnBitMap = null;
        if (!Directory.Exists(fPath)) { Directory.CreateDirectory(fPath); }
        if (!Directory.Exists(fyPath)) { Directory.CreateDirectory(fyPath); }
        if (!Directory.Exists(zfPath)) { Directory.CreateDirectory(zfPath); }

        if (File.Exists(fullPath))
        {
            //returnBitMap = new Bitmap(fullPath);
            context.Response.Redirect("http://localhost/IS/Output/GoogleMapCache/"+mapType+"/"+ms.ToString()+"/"+imgName);
        }
        else
        {
            //leftTop是根据经纬度[-180,85]计算得来的
            //GoogleMap起始坐标
            MapCoord leftTop = new MapCoord(-2.0037508342789244E7, 1.9929239112930678E7);
            //leftTop.X += Double.Parse(offsetX);//1300
            //leftTop.Y += Double.Parse(offsetY); //-6500
            leftTop.X += 1300;
            leftTop.Y += -6500;
            double tileWidth = (-leftTop.X) / Math.Pow(2.0, z - 1);
            double tileHeight = leftTop.Y / Math.Pow(2.0, z - 1);
            //角点所在的图幅
            int x1 = (int)((viewBounds.LeftBottom.X - leftTop.X) / tileWidth);
            int y1 = (int)((leftTop.Y - viewBounds.LeftBottom.Y) / tileHeight);
            int x2 = (int)((viewBounds.RightTop.X - leftTop.X) / tileWidth);
            int y2 = (int)((leftTop.Y - viewBounds.RightTop.Y) / tileHeight);
            //拼接图幅的范围
            MapRect nowViewBounds = new MapRect();
            nowViewBounds.LeftBottom = new MapCoord();
            nowViewBounds.RightTop = new MapCoord();
            nowViewBounds.LeftBottom.X = leftTop.X + x1 * tileWidth;
            nowViewBounds.RightTop.X = leftTop.X + (x2 + 1) * tileWidth;
            nowViewBounds.RightTop.Y = leftTop.Y - y2 * tileHeight;
            nowViewBounds.LeftBottom.Y = leftTop.Y - (y1 + 1) * tileHeight;
            Bitmap bitMap = null;
            bitMap = GetImg(x1, x2, y1, y2, z);
            // bitMap.Save(zfPath + @"\f" + imgName);
            //切图起点  
            int imgWidth = 256 * (x2 - x1 + 1);
            int imgHeight = 256 * (y1 - y2 + 1);
            int xt = (int)(((viewBounds.LeftBottom.X - nowViewBounds.LeftBottom.X) / nowViewBounds.Width) * imgWidth);
            int yt = (int)(((nowViewBounds.RightTop.Y - viewBounds.RightTop.Y) / nowViewBounds.Height) * imgHeight);
            int width = (int)((viewBounds.Width / nowViewBounds.Width) * imgWidth); ;
            int height = (int)((viewBounds.Height / nowViewBounds.Height) * imgHeight);
            returnBitMap = cutMap(bitMap, xt, yt, width, height);
            if ((width != 256 && width != 257) || (height != 256 && height != 257))
            {
                returnBitMap = resizeImg(returnBitMap);
            }
            if (!File.Exists(fullPath))
            {
                returnBitMap.Save(fullPath);
            }
            bitMap.Dispose();
            MemoryStream mss = new MemoryStream();
            returnBitMap.Save(mss, System.Drawing.Imaging.ImageFormat.Png);
            byte[] ImgBytes = mss.ToArray();
            context.Response.BinaryWrite(ImgBytes);
            context.Response.End();
        }       
     }
    //重置大小
    private Bitmap resizeImg(Bitmap bitMap)
    {
        Bitmap newBitMap = new Bitmap(bitMap, 256, 256);      
        return newBitMap;
    }
    //获取地图比例尺
    private int GetZoomLevel(double width, double height)
    {
        double h = tileBaseHeight / height;
        double w = tileBaseWidth / width;
        if (h < 1)
        {
            return 0;
        }
        else
        {
            int hi = (int)(Math.Log(h, 2)) + 1;
            int wi = (int)(Math.Log(w, 2)) + 1;
            int returnI = (hi < wi) ? hi : wi;
            if (returnI > 16)
            {
                if (mapType == "Satellite")
                {
                    returnI = 16;
                }
                else
                {
                    returnI = 17;
                }
            }
            return returnI;
        }
    }
    //切图
    public Bitmap cutMap(Bitmap b, int StartX, int StartY, int iWidth, int iHeight)
    {
        if (b == null) { return null; }
        int w = b.Width;
        int h = b.Height;
        if (StartX >= w || StartY >= h) { return null; }
        if (StartX + iWidth > w) { iWidth = w - StartX; }
        if (StartY + iHeight > h) { iHeight = h - StartY; }
        try
        {
            Bitmap bmpOut = new Bitmap(iWidth, iHeight);           
            Graphics g = Graphics.FromImage(bmpOut);
            g.DrawImage(b, new Rectangle(0, 0, iWidth, iHeight), new Rectangle(StartX, StartY, iWidth, iHeight), GraphicsUnit.Pixel);
            g.Dispose();
            return bmpOut;
        }
        catch
        {
            return null;
        }
    }
    //获取图片
    private Bitmap GetImg(int x1, int x2, int y1, int y2, int z)
    {
        int xCount = x2 - x1 + 1;
        int yCount = y1 - y2 + 1;
        Bitmap[] bitmaps = new Bitmap[xCount * yCount];
        int index = 0;
        for (int i = 0; i < yCount; i++)
        {
            for (int j = 0; j < xCount; j++)
            {
                bitmaps[index] = new Bitmap(getStream(j + x1, i + y2, z));
                index++;
            }
        }
        Bitmap newBitmap = MergerImg(bitmaps, xCount, yCount);
        return newBitmap;
    }
    //合并图片
    private Bitmap MergerImg(Bitmap[] maps, int xCount, int yCount)
    {
        Bitmap backgroudImg = new Bitmap(xCount * 256, yCount * 256);
        Graphics g = Graphics.FromImage(backgroudImg);
        g.Clear(System.Drawing.Color.White);
        int index = 0;
        for (int j = 0; j < yCount; j++)
        {
            for (int k = 0; k < xCount; k++)
            {
                g.DrawImage(maps[index], k * 256, j * 256, 256, 256);
                index++;
            }
        }
        g.Dispose();
        return backgroudImg;
    }
    //获取图片Stream
    public Stream getStream(int x, int y, int z)
    {
        Stream stream = null;
        if (x < 0 || y < 0)
        {
            stream = WriteImg();
        }
        else
        {           
            string imageUrl = GetTileUrl(x, y, z);
            HttpWebRequest myHttpWebRequest = null;
            HttpWebResponse myHttpWebResponse = null;
            Uri imageUri = new Uri(imageUrl, UriKind.RelativeOrAbsolute);
            try
            {
                myHttpWebRequest = (HttpWebRequest)WebRequest.Create(imageUri);
                myHttpWebRequest.AllowAutoRedirect = true;
                myHttpWebRequest.AllowWriteStreamBuffering = true;
                myHttpWebResponse = (HttpWebResponse)myHttpWebRequest.GetResponse();
                stream = myHttpWebResponse.GetResponseStream();
            }
            catch (System.Net.WebException we)
            {
                stream = WriteImg();
            }
            catch (Exception)
            {
                stream = WriteImg();
            }
        }
        return stream;
    }
    //获取白图填充
    private Stream WriteImg()
    {
        Stream stream = null;
        Bitmap writeImgB = null;
        string writeImg = OutPutPath + @"\writeImg.png";
        MemoryStream ms = new MemoryStream();
        if (File.Exists(writeImg))
        {
            writeImgB = new Bitmap(writeImg);
        }
        else
        {
            //绘制白图            
            writeImgB = new Bitmap(256, 256);
            Graphics g = Graphics.FromImage(writeImgB);
            Pen penColor = new Pen(Color.White, 256);
            g.DrawRectangle(penColor, new Rectangle(0, 0, 256, 256));
            penColor.Dispose();
            g.Dispose();
            writeImgB.MakeTransparent(Color.White);
            if (!File.Exists(writeImg))
            {
                writeImgB.Save(writeImg);
            }
        }
        writeImgB.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
        stream = ms as Stream;
        return stream;
    }
    //获取图片的Url
    private string GetTileUrl(int indexX, int indexY, int level)
    {
        Random r = new Random();
        int i = r.Next(0,3);
        return string.Format(Uris[mapType], i, indexX, indexY, level);
    }
    public bool IsReusable
    {
        get
        {
            return false;
        }
    }

}
标题SpringBoot智能在线预约挂号系统研究AI更换标题第1章引言介绍智能在线预约挂号系统的研究背景、意义、国内外研究现状及论文创新点。1.1研究背景与意义阐述智能在线预约挂号系统对提升医疗服务效率的重要性。1.2国内外研究现状分析国内外智能在线预约挂号系统的研究与应用情况。1.3研究方法及创新点概述本文采用的技术路线、研究方法及主要创新点。第2章相关理论总结智能在线预约挂号系统相关理论,包括系统架构、开发技术等。2.1系统架构设计理论介绍系统架构设计的基本原则和常用方法。2.2SpringBoot开发框架理论阐述SpringBoot框架的特点、优势及其在系统开发中的应用。2.3数据库设计与管理理论介绍数据库设计原则、数据模型及数据库管理系统。2.4网络安全与数据保护理论讨论网络安全威胁、数据保护技术及其在系统中的应用。第3章SpringBoot智能在线预约挂号系统设计详细介绍系统的设计方案,包括功能模块划分、数据库设计等。3.1系统功能模块设计划分系统功能模块,如用户管理、挂号管理、医生排班等。3.2数据库设计与实现设计数据库表结构,确定字段类型、主键及外键关系。3.3用户界面设计设计用户友好的界面,提升用户体验。3.4系统安全设计阐述系统安全策略,包括用户认证、数据加密等。第4章系统实现与测试介绍系统的实现过程,包括编码、测试及优化等。4.1系统编码实现采用SpringBoot框架进行系统编码实现。4.2系统测试方法介绍系统测试的方法、步骤及测试用例设计。4.3系统性能测试与分析对系统进行性能测试,分析测试结果并提出优化建议。4.4系统优化与改进根据测试结果对系统进行优化和改进,提升系统性能。第5章研究结果呈现系统实现后的效果,包括功能实现、性能提升等。5.1系统功能实现效果展示系统各功能模块的实现效果,如挂号成功界面等。5.2系统性能提升效果对比优化前后的系统性能
在金融行业中,对信用风险的判断是核心环节之一,其结果对机构的信贷政策和风险控制策略有直接影响。本文将围绕如何借助机器学习方法,尤其是Sklearn工具包,建立用于判断信用状况的预测系统。文中将涵盖逻辑回归、支持向量机等常见方法,并通过实际操作流程进行说明。 一、机器学习基本概念 机器学习属于人工智能的子领域,其基本理念是通过数据自动学习规律,而非依赖人工设定规则。在信贷分析中,该技术可用于挖掘历史数据中的潜在规律,进而对未来的信用表现进行预测。 二、Sklearn工具包概述 Sklearn(Scikit-learn)是Python语言中广泛使用的机器学习模块,提供多种数据处理和建模功能。它简化了数据清洗、特征提取、模型构建、验证与优化等流程,是数据科学项目中的常用工具。 三、逻辑回归模型 逻辑回归是一种常用于分类任务的线性模型,特别适用于二类问题。在信用评估中,该模型可用于判断借款人是否可能违约。其通过逻辑函数将输出映射为0到1之间的概率值,从而表示违约的可能性。 四、支持向量机模型 支持向量机是一种用于监督学习的算法,适用于数据维度高、样本量小的情况。在信用分析中,该方法能够通过寻找最佳分割面,区分违约与非违约客户。通过选用不同核函数,可应对复杂的非线性关系,提升预测精度。 五、数据预处理步骤 在建模前,需对原始数据进行清理与转换,包括处理缺失值、识别异常点、标准化数值、筛选有效特征等。对于信用评分,常见的输入变量包括收入水平、负债比例、信用历史记录、职业稳定性等。预处理有助于减少噪声干扰,增强模型的适应性。 六、模型构建与验证 借助Sklearn,可以将数据集划分为训练集和测试集,并通过交叉验证调整参数以提升模型性能。常用评估指标包括准确率、召回率、F1值以及AUC-ROC曲线。在处理不平衡数据时,更应关注模型的召回率与特异性。 七、集成学习方法 为提升模型预测能力,可采用集成策略,如结合多个模型的预测结果。这有助于降低单一模型的偏差与方差,增强整体预测的稳定性与准确性。 综上,基于机器学习的信用评估系统可通过Sklearn中的多种算法,结合合理的数据处理与模型优化,实现对借款人信用状况的精准判断。在实际应用中,需持续调整模型以适应市场变化,保障预测结果的长期有效性。 资源来源于网络分享,仅用于学习交流使用,请勿用于商业,如有侵权请联系我删除!
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值