using System.Web.Http;
using System.Web.Mvc;
 
namespace ThinkGeo.MapSuite.Layers
{
    // Note: For instructions on enabling IIS6 or IIS7 classic mode, 
    // visit http://go.microsoft.com/?LinkId=9394801
 
    public class WebApiApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
 
            WebApiConfig.Register(GlobalConfiguration.Configuration);
        }
    }
}

using System.Web.Http;
 
namespace ThinkGeo.MapSuite.Layers
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            //Enable RouteAttribute
            config.MapHttpAttributeRoutes();
 
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
 
            //Enable RouteAttribute, if delete this line, will throw other exceptions
            config.EnsureInitialized();
        }
    }
}

using System;
using System.Collections.ObjectModel;
using System.Reflection;
using ThinkGeo.MapSuite.Core;
using System.Globalization;
using System.Reflection;
 
namespace Layers.Controllers
{
    public class DescriptionAdornmentLayer : AdornmentLayer
    {
        private const int rightStart = 10;
        private const int yPosition = 10;
        private string drawingText = string.Empty;
 
        [Obfuscation(Exclude = true)]
        private ScreenUnit screenUnit;
 
        [Obfuscation(Exclude = true)]
        private DistanceUnit worldUnit;
 
        [Obfuscation(Exclude = true)]
        private GeoFont font;
        [Obfuscation(Exclude = true)]
        private GeoBrush textBrush;
        [Obfuscation(Exclude = true)]
        private int width;
        [Obfuscation(Exclude = true)]
        private int height;
        [Obfuscation(Exclude = true)]
        private ScreenPointF screenLocation;
 
        public DescriptionAdornmentLayer()
            : this(ScreenUnit.Centimeter, DistanceUnit.Kilometer, new GeoFont("Microsoft Sans Serif", 20F, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black))
        { }
 
        public DescriptionAdornmentLayer(ScreenUnit screenUnit, DistanceUnit worldUnit)
            : this(screenUnit, worldUnit, new GeoFont("Microsoft Sans Serif", 20F, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black))
        { }
 
        public DescriptionAdornmentLayer(ScreenUnit screenUnit, DistanceUnit worldUnit, GeoFont font, GeoBrush textBrush)
            : base()
        {
            this.screenUnit = screenUnit;
            this.worldUnit = worldUnit;
            width = 392;
            height = 32;
            this.font = font;
            this.textBrush = textBrush;
            Location = AdornmentLocation.LowerLeft;
        }
 
        public string DrawingText
        {
            set { this.drawingText = value; }
            get { return drawingText; }
        }
 
        public ScreenUnit ScreenUnit
        {
            get { return screenUnit; }
            set { screenUnit = value; }
        }
 
        public DistanceUnit WorldUnit
        {
            get { return worldUnit; }
            set { worldUnit = value; }
        }
 
        public GeoFont Font
        {
            get { return font; }
            set { font = value; }
        }
 
        public GeoBrush TextBrush
        {
            get { return textBrush; }
            set { textBrush = value; }
        }
 
        protected override void DrawCore(GeoCanvas canvas, Collection<SimpleCandidate> labelsInAllLayers)
        {
            screenLocation = GetDrawingLocation(canvas, width, height);
            ScreenPointF ptStart = new ScreenPointF(rightStart + screenLocation.X, yPosition + screenLocation.Y);
 
            DrawingRectangleF rectangle = canvas.MeasureText(drawingText, font);
            PointShape textLocation = ExtentHelper.ToWorldCoordinate(canvas.CurrentWorldExtent, new ScreenPointF(ptStart.X + rectangle.Width / 2, screenLocation.Y + rectangle.Height / 2), canvas.Width, canvas.Height);
            canvas.DrawTextWithWorldCoordinate(drawingText, font, textBrush, textLocation.X, textLocation.Y, DrawingLevel.LabelLevel);
 
            base.DrawCore(canvas, labelsInAllLayers);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Web.Http;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.WebApiEdition;
 
namespace ThinkGeo.MapSuite.Layers
{
    [RoutePrefix("layers")]
    public class LayersController : ApiController
    {
        private static readonly string baseDirectory;
        private static ManagedProj4Projection wgs84ToGoogleProjection;
        private static ManagedProj4Projection feetToGoogleProjection;
        private static readonly NoaaRadarRasterLayer noaaRadarRasterLayer;
        private static readonly NoaaWeatherStationFeatureLayer noaaWeatherStationFeatureLayer;
 
        static LayersController()
        {
            baseDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "App_Data");
 
            InitializeProjection();
 
            // Noaa layers need to download the imformantion from server, we can open to start downloading data when application starting.
            noaaRadarRasterLayer = new NoaaRadarRasterLayer();
            noaaRadarRasterLayer.Name = "noaaRadar";
            noaaRadarRasterLayer.ImageSource.Projection = wgs84ToGoogleProjection;
            NoaaRadarMonitor.RadarUpdated += (sender, args) => NoaaRadarMonitor.StopMonitoring();
            noaaRadarRasterLayer.Open();
 
            noaaWeatherStationFeatureLayer = new NoaaWeatherStationFeatureLayer();
            noaaWeatherStationFeatureLayer.Name = "noaaWeather";
            noaaWeatherStationFeatureLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(new NoaaWeatherStationStyle());
            noaaWeatherStationFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            noaaWeatherStationFeatureLayer.FeatureSource.Projection = wgs84ToGoogleProjection;
            NoaaWeatherStationMonitor.StationsUpdated += (sender, args) => NoaaWeatherStationMonitor.StopMonitoring();
            noaaWeatherStationFeatureLayer.Open();
        }
 
        //Vector Based Layers
        [Route("VectorLayers/shapeFile/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadShapeFile(int z, int x, int y)
        {
            string shpFilePathName = string.Format(@"{0}\ShapeFile\USStates.shp", baseDirectory);
            ShapeFileFeatureLayer shapeFileFeatureLayer = new ShapeFileFeatureLayer(shpFilePathName);
            shapeFileFeatureLayer.Name = "shapeFile";
            shapeFileFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush = new GeoSolidBrush(new GeoColor(50, GeoColor.SimpleColors.Orange));
            shapeFileFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen = new GeoPen(GeoColor.SimpleColors.Black);
            shapeFileFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(shapeFileFeatureLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("VectorLayers/tab/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadTabFile(int z, int x, int y)
        {
            string tabFilePathName = string.Format(@"{0}\TAB\USStates.tab", baseDirectory);
            TabFeatureLayer tabFeatureLayer = new TabFeatureLayer(tabFilePathName);
            tabFeatureLayer.StylingType = TabStylingType.StandardStyling;
            tabFeatureLayer.Name = "tab";
            tabFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush = new GeoSolidBrush(new GeoColor(50, GeoColor.SimpleColors.Orange));
            tabFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen = new GeoPen(GeoColor.SimpleColors.Black);
            tabFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            tabFeatureLayer.FeatureSource.Projection = wgs84ToGoogleProjection;
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(tabFeatureLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("VectorLayers/tinyGeo/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadTinyGeo(int z, int x, int y)
        {
            string tinyGeoFilePathName = string.Format(@"{0}\TinyGeo\USStates.tgeo", baseDirectory);
 
            TinyGeoFeatureLayer tinyGeoFeatureLayer = new TinyGeoFeatureLayer(tinyGeoFilePathName);
            tinyGeoFeatureLayer.Name = "tinyGeo";
            tinyGeoFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush = new GeoSolidBrush(new GeoColor(50, GeoColor.SimpleColors.Orange));
            tinyGeoFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen = new GeoPen(GeoColor.SimpleColors.Black);
            tinyGeoFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(tinyGeoFeatureLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("VectorLayers/fileGeoDatabase/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadFileGeoDatabase(int z, int x, int y)
        {
            string fileGeoDatabaeFilePathName = string.Format(@"{0}\FileGeoDatabase\USStates.gdb", baseDirectory);
            FileGeoDatabaseFeatureLayer fileGeoDatabaseLayer = new FileGeoDatabaseFeatureLayer(fileGeoDatabaeFilePathName, "USStates");
            fileGeoDatabaseLayer.Name = "fileGeoDatabase";
            fileGeoDatabaseLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush = new GeoSolidBrush(new GeoColor(50, GeoColor.SimpleColors.Orange));
            fileGeoDatabaseLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen = new GeoPen(GeoColor.SimpleColors.Black);
            fileGeoDatabaseLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            fileGeoDatabaseLayer.FeatureSource.Projection = wgs84ToGoogleProjection;
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(fileGeoDatabaseLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("VectorLayers/sqlite/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadSqlite(int z, int x, int y)
        {
            string fileConnectionStr = string.Format(@"Data Source={0}\Sqlite\USStates.sqlite;Version=3;", baseDirectory);
            SqliteFeatureLayer sqliteFeatureLayer = new SqliteFeatureLayer(fileConnectionStr, "table_name", "id", "geometry");
            sqliteFeatureLayer.Name = "sqlite";
            sqliteFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush = new GeoSolidBrush(new GeoColor(50, GeoColor.SimpleColors.Orange));
            sqliteFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen = new GeoPen(GeoColor.SimpleColors.Black);
            sqliteFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(sqliteFeatureLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("VectorLayers/wkb/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadWkbFile(int z, int x, int y)
        {
            string mrSidFilePathName = string.Format(@"{0}\Wkb\USStates.wkb", baseDirectory);
            WkbFileFeatureLayer wkbFileFeatureLayer = new WkbFileFeatureLayer(mrSidFilePathName);
            wkbFileFeatureLayer.Name = "wkb";
            wkbFileFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush = new GeoSolidBrush(new GeoColor(50, GeoColor.SimpleColors.Orange));
            wkbFileFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen = new GeoPen(GeoColor.SimpleColors.Black);
            wkbFileFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(wkbFileFeatureLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("VectorLayers/kml/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadKmlFile(int z, int x, int y)
        {
            string kmlFilePathName = string.Format(@"{0}\KML\ThinkGeoHeadquarters.kml", baseDirectory);
            KmlFeatureLayer kmlFeatureLayer = new KmlFeatureLayer(kmlFilePathName, KmlStylingType.StandardStyling);
            kmlFeatureLayer.Name = "kml";
 
            TextStyle textStyle = new TextStyle("name", (new GeoFont("Arial", 12)), new GeoSolidBrush(GeoColor.StandardColors.DarkOliveGreen));
            textStyle.HaloPen = new GeoPen(GeoColor.StandardColors.FloralWhite, 5);
            textStyle.SplineType = SplineType.ForceSplining;
 
            kmlFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush = new GeoSolidBrush(new GeoColor(50, GeoColor.SimpleColors.Orange));
            kmlFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen = new GeoPen(GeoColor.SimpleColors.Black);
            kmlFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.SimpleColors.Orange, 5));
            kmlFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolPen = new GeoPen(GeoColor.FromArgb(255, GeoColor.StandardColors.Green), 8);
            kmlFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;
            kmlFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(kmlFeatureLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("VectorLayers/mapShape/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadMapShapeLayer(int z, int x, int y)
        {
            MapShapeLayer mapShapeLayer = new MapShapeLayer();
            mapShapeLayer.Name = "mapShape";
 
            TextStyle textStyle = new TextStyle("name", (new GeoFont("Arial", 12)), new GeoSolidBrush(GeoColor.StandardColors.DarkOliveGreen));
            textStyle.HaloPen = new GeoPen(GeoColor.StandardColors.FloralWhite, 5);
            textStyle.SplineType = SplineType.ForceSplining;
            GeoPen pointPen = new GeoPen(GeoColor.FromArgb(255, GeoColor.StandardColors.Green), 8);
            LineStyle lineStyle = new LineStyle(new GeoPen(GeoColor.SimpleColors.Orange, 5));
 
            int polygonCount = 1;
            IEnumerable<Feature> mapShapeLayerFeatures = SampleHelper.GetFeatures("MapShapeLayer");
            foreach (var feature in mapShapeLayerFeatures)
            {
                MapShape mapShape = new MapShape(feature);
                switch (feature.GetWellKnownType())
                {
                    case WellKnownType.Point:
                        mapShape.ZoomLevels.ZoomLevel01.DefaultPointStyle.SymbolPen = pointPen;
                        mapShape.ZoomLevels.ZoomLevel01.DefaultTextStyle = textStyle;
                        mapShape.ZoomLevels.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
                        mapShapeLayer.MapShapes.Add(feature.Id, mapShape);
                        break;
                    case WellKnownType.Line:
                        mapShape.ZoomLevels.ZoomLevel01.DefaultLineStyle = lineStyle;
                        mapShape.ZoomLevels.ZoomLevel01.DefaultTextStyle = textStyle;
                        mapShape.ZoomLevels.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
                        mapShapeLayer.MapShapes.Add(feature.Id, mapShape);
                        break;
                    case WellKnownType.Polygon:
                        if (polygonCount == 1)
                            mapShape.ZoomLevels.ZoomLevel01.DefaultAreaStyle = WorldMapKitAreaStyles.Park();
 
                        if (polygonCount == 2)
                            mapShape.ZoomLevels.ZoomLevel01.DefaultAreaStyle = WorldMapKitAreaStyles.School();
 
                        if (polygonCount == 3)
                            mapShape.ZoomLevels.ZoomLevel01.DefaultAreaStyle = WorldMapKitAreaStyles.Water();
                        mapShape.ZoomLevels.ZoomLevel01.DefaultTextStyle = textStyle;
                        mapShape.ZoomLevels.ZoomLevel01.DefaultAreaStyle.OutlinePen = new GeoPen(GeoColor.SimpleColors.Black);
                        mapShape.ZoomLevels.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
                        mapShapeLayer.MapShapes.Add(feature.Id, mapShape);
                        polygonCount++;
 
                        break;
                }
            }
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(mapShapeLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("VectorLayers/inMemoryFeature/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadInMemoryLayer(int z, int x, int y)
        {
            InMemoryFeatureLayer inMemoryFeatureLayer = new InMemoryFeatureLayer();
            inMemoryFeatureLayer.Name = "inMemoryFeature";
            IEnumerable<Feature> inMemoryLayerFeatures = SampleHelper.GetFeatures("InMemoryLayer");
            foreach (var feature in inMemoryLayerFeatures)
            {
                inMemoryFeatureLayer.InternalFeatures.Add(feature);
            }
            inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(100, GeoColor.StandardColors.RoyalBlue);
            inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Blue;
            inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen = new GeoPen(GeoColor.FromArgb(200, GeoColor.StandardColors.Red), 5);
            inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolPen = new GeoPen(GeoColor.FromArgb(255, GeoColor.StandardColors.Green), 8);
            TextStyle textStyle = new TextStyle("name", (new GeoFont("Arial", 12)), new GeoSolidBrush(GeoColor.StandardColors.DarkOliveGreen));
            textStyle.HaloPen = new GeoPen(GeoColor.StandardColors.FloralWhite, 3);
            inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;
            inMemoryFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(inMemoryFeatureLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        //Raster Based Layers
        [Route("RasterLayers/mrsid/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadMrsidFile(int z, int x, int y)
        {
            LayerOverlay layerOverlay = new LayerOverlay();
 
            string mrSidFilePathName = string.Format(@"{0}\MrSid\US380AndGeeRoad.sid", baseDirectory);
            MrSidRasterLayer mrsidRasterLayer = new MrSidRasterLayer(mrSidFilePathName);
            mrsidRasterLayer.Name = "mrsid";
            mrsidRasterLayer.ImageSource.Projection = feetToGoogleProjection;
            layerOverlay.Layers.Add(mrsidRasterLayer);
 
            ShapeFileFeatureLayer txlka40FeatureLayer = new ShapeFileFeatureLayer(string.Format(@"{0}\MrSid\TXlkaA40.shp", baseDirectory));
            txlka40FeatureLayer.ZoomLevelSet.ZoomLevel17.DefaultLineStyle = WorldMapKitLineStyles.RoadFill(8);
            txlka40FeatureLayer.ZoomLevelSet.ZoomLevel17.DefaultTextStyle = WorldMapKitTextStyles.GeneralPurpose("[fedirp] [fename] [fetype] [fedirs]", 10f);
            txlka40FeatureLayer.ZoomLevelSet.ZoomLevel17.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            layerOverlay.Layers.Add("TXlkaA40", txlka40FeatureLayer);
 
            ShapeFileFeatureLayer txlkaA20FeatureLayer = new ShapeFileFeatureLayer(string.Format(@"{0}\MrSid\TXlkaA20.shp", baseDirectory));
            txlkaA20FeatureLayer.ZoomLevelSet.ZoomLevel17.DefaultLineStyle = WorldMapKitLineStyles.Highway(10);
            txlkaA20FeatureLayer.ZoomLevelSet.ZoomLevel17.DefaultTextStyle = WorldMapKitTextStyles.TrunkRoadSheild("[fedirp] [fename] [fetype] [fedirs]", 10f);
            txlkaA20FeatureLayer.ZoomLevelSet.ZoomLevel17.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            layerOverlay.Layers.Add("TXlkaA20", txlkaA20FeatureLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("RasterLayers/jpeg2000/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadJpeg2000(int z, int x, int y)
        {
            string jpeg2000FilePathName = string.Format(@"{0}\Jpeg2000\World.jp2", baseDirectory);
            string jpeg2000WorldFilePathName = Path.ChangeExtension(jpeg2000FilePathName, ".j2w");
            Jpeg2000RasterLayer jpeg2000RasterLayer = new Jpeg2000RasterLayer(jpeg2000FilePathName, jpeg2000WorldFilePathName);
            jpeg2000RasterLayer.Name = "jpeg2000";
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(jpeg2000RasterLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("RasterLayers/geotiff/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadGeoTiff(int z, int x, int y)
        {
            string tiffFilePathName = string.Format(@"{0}\Tiff\World.tif", baseDirectory);
            string tiffWorldFilePathName = Path.ChangeExtension(tiffFilePathName, "tfw");
            GeoTiffRasterLayer geoTiffRasterLayer = new GeoTiffRasterLayer(tiffFilePathName, tiffWorldFilePathName);
            geoTiffRasterLayer.Name = "geotiff";
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(geoTiffRasterLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("RasterLayers/nativeImage/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadNativeImage(int z, int x, int y)
        {
            GdiPlusRasterLayer gdiPlusRasterLayer = new GdiPlusRasterLayer(string.Format(@"{0}\PNG\ThinkGeoLogo.png", baseDirectory),
                new RectangleShape(-10776876.6105256, 3912354.07403825, -10776796.6105256, 3912334.07403825));
            gdiPlusRasterLayer.Name = "nativeImage";
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(gdiPlusRasterLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        // Web Based Layers WebServiceLayers
        [Route("WebServiceLayers/noaaRadar/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadNoaaRadar(int z, int x, int y)
        {
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(noaaRadarRasterLayer);
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("WebServiceLayers/noaaWeather/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadNoaaWeatherStation(int z, int x, int y)
        {
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(noaaWeatherStationFeatureLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        [Route("WebServiceLayers/wms/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadWms(int z, int x, int y)
        {
            WmsRasterLayer wmsLayer = new WmsRasterLayer();
            wmsLayer.Name = "wms";
            wmsLayer.Crs = "EPSG:900913";
            wmsLayer.Uri = new Uri("http://howdoiwms.thinkgeo.com/WmsServer.aspx");
            wmsLayer.ActiveLayerNames.Add("COUNTRIES02");
            wmsLayer.ActiveLayerNames.Add("USSTATES");
            wmsLayer.ActiveLayerNames.Add("USMAJORCITIES");
            wmsLayer.Parameters.Add("STYLES", "SIMPLE");
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(wmsLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        // Customized Layers
        [Route("CustomizedLayers/customized/{z}/{x}/{y}")]
        [HttpGet]
        public HttpResponseMessage LoadCustomized(int z, int x, int y)
        {
            ThinkGeoHeadquartersFeatureLayer thinkGeoHeadquartersFeatureLayer = new ThinkGeoHeadquartersFeatureLayer();
            thinkGeoHeadquartersFeatureLayer.Name = "CustomizedLayer";
 
            TextStyle textStyle = new TextStyle("name", (new GeoFont("Arial", 12)), new GeoSolidBrush(GeoColor.StandardColors.DarkOliveGreen));
            textStyle.HaloPen = new GeoPen(GeoColor.StandardColors.FloralWhite, 5);
            textStyle.SplineType = SplineType.ForceSplining;
 
            thinkGeoHeadquartersFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush = new GeoSolidBrush(new GeoColor(50, GeoColor.SimpleColors.Orange));
            thinkGeoHeadquartersFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen = new GeoPen(GeoColor.SimpleColors.Black);
            thinkGeoHeadquartersFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.SimpleColors.Orange, 5));
            thinkGeoHeadquartersFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolPen = new GeoPen(GeoColor.FromArgb(255, GeoColor.StandardColors.Green), 8);
            thinkGeoHeadquartersFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;
            thinkGeoHeadquartersFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
 
            LayerOverlay layerOverlay = new LayerOverlay();
            layerOverlay.Layers.Add(thinkGeoHeadquartersFeatureLayer);
 
            return DrawTileImage(layerOverlay, z, x, y);
        }
 
        private static void InitializeProjection()
        {
            wgs84ToGoogleProjection = new ManagedProj4Projection();
            wgs84ToGoogleProjection.InternalProjectionParametersString = Proj4Projection.GetWgs84ParametersString();
            wgs84ToGoogleProjection.ExternalProjectionParametersString = Proj4Projection.GetGoogleMapParametersString();
            wgs84ToGoogleProjection.Open();
 
            string projWkt = File.ReadAllText(string.Format(@"{0}\MrSid\US380AndGeeRoad.prj", baseDirectory));
            feetToGoogleProjection = new ManagedProj4Projection();
            feetToGoogleProjection.InternalProjectionParametersString = Proj4Projection.ConvertPrjToProj4(projWkt);
            feetToGoogleProjection.ExternalProjectionParametersString = Proj4Projection.GetGoogleMapParametersString();
            feetToGoogleProjection.Open();
        }
 
        private HttpResponseMessage DrawTileImage(LayerOverlay layerOverlay, int z, int x, int y)
        {
            using (Bitmap bitmap = new Bitmap(256, 256))
            {
                GdiPlusGeoCanvas geoCanvas = new GdiPlusGeoCanvas();
                RectangleShape boundingBox = WebApiExtentHelper.GetBoundingBoxForXyz(x, y, z, GeographyUnit.Meter);
                geoCanvas.BeginDrawing(bitmap, boundingBox, GeographyUnit.Meter);
                layerOverlay.Draw(geoCanvas);
                geoCanvas.EndDrawing();
 
                MemoryStream ms = new MemoryStream();
                bitmap.Save(ms, ImageFormat.Png);
 
                HttpResponseMessage msg = new HttpResponseMessage(HttpStatusCode.OK);
                msg.Content = new ByteArrayContent(ms.ToArray());
                msg.Content.Headers.ContentType = new MediaTypeHeaderValue("image/png");
 
                return msg;
            }
        }
    }
}

using ThinkGeo.MapSuite.Core;
 
namespace ThinkGeo.MapSuite.Layers
{
    public class ThinkGeoHeadquartersFeatureLayer : FeatureLayer
    {
        public ThinkGeoHeadquartersFeatureLayer()
        {
            FeatureSource = new ThinkGeoHeadquartersFeatureSource();
        }
    }
}

using System.Collections.Generic;
using System.Collections.ObjectModel;
using ThinkGeo.MapSuite.Core;
 
namespace ThinkGeo.MapSuite.Layers
{
    public class ThinkGeoHeadquartersFeatureSource : FeatureSource
    {
        protected override Collection<Feature> GetAllFeaturesCore(IEnumerable<string> returningColumnNames)
        {
            return SampleHelper.GetFeatures("CustomizedLayer");
        }
    }
}

using System;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using ThinkGeo.MapSuite.Core;
 
namespace ThinkGeo.MapSuite.Layers
{
    public static class SampleHelper
    {
        public static Collection<Feature> GetFeatures(string layerType)
        {
            Collection<Feature> features = new Collection<Feature>();
            XElement layerData = XElement.Load(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "App_Data/LayerData.xml"));
            XElement featureElements = layerData.Elements("Layer").FirstOrDefault(a => a.Attribute("type").Value.Contains(layerType));
            if (featureElements != null)
            {
                foreach (var featureItem in featureElements.Elements("Feature"))
                {
                    Feature feature = new Feature(featureItem.Value);
                    XAttribute featureAttribute = featureItem.FirstAttribute;
                    feature.ColumnValues[featureAttribute.Name.ToString()] = featureAttribute.Value;
 
                    features.Add(feature);
                }
            }
            return features;
        }
    }
}

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
 
// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Layers")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Layers")]
[assembly: AssemblyCopyright("Copyright ©  2015")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
 
// Setting ComVisible to false makes the types in this assembly not visible 
// to COM components.  If you need to access a type in this assembly from 
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
 
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("395a1cf3-3a8b-4865-843a-10dd37dd96e4")]
 
// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Revision and Build Numbers 
// by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

using System;
using System.Web;
using System.Web.Http;
using System.Web.Mvc;
using System.Web.SessionState;
 
namespace ThinkGeo
{
    // Note: For instructions on enabling IIS6 or IIS7 classic mode, 
    // visit http://go.microsoft.com/?LinkId=9394801
 
    public class WebApiApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
 
            WebApiConfig.Register(GlobalConfiguration.Configuration);
        }
    }
}

using System.Web.Http;
 
namespace ThinkGeo
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            //Enable RouteAttribute
            config.MapHttpAttributeRoutes();
 
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
 
            //Enable RouteAttribute, if delete this line, will throw other exceptions
            config.EnsureInitialized();
        }
    }
}

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
 
// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Layers")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Layers")]
[assembly: AssemblyCopyright("Copyright ©  2015")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
 
// Setting ComVisible to false makes the types in this assembly not visible 
// to COM components.  If you need to access a type in this assembly from 
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
 
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("395a1cf3-3a8b-4865-843a-10dd37dd96e4")]
 
// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Revision and Build Numbers 
// by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]