ThinkGeo Cloud
ThinkGeo UI Controls
ThinkGeo Open Source
Help and Support
External Resources
ThinkGeo Cloud
ThinkGeo UI Controls
ThinkGeo Open Source
Help and Support
External Resources
using System; using System.Collections.ObjectModel; using System.Web.Mvc; using ThinkGeo.MapSuite.Core; using ThinkGeo.MapSuite.EarthquakeStatistics; using ThinkGeo.MapSuite.MvcEdition; using System.Linq; using System.Collections.Generic; using System.Configuration; namespace ThinkGeo.MapSuite.EarthquakeStatistics.Controllers { public class DefaultController : Controller { public ActionResult Index() { // Initialize map for the page Map map = InitializeMap(); return View(map); } [MapActionFilter] public void SetDrawMode(Map map, GeoCollection<object> args) { switch (args[0].ToString()) { case "DrawCircle": map.EditOverlay.TrackMode = TrackMode.Circle; break; case "DrawRectangle": map.EditOverlay.TrackMode = TrackMode.Rectangle; break; case "DrawPolygon": map.EditOverlay.TrackMode = TrackMode.Polygon; break; case "ClearAll": ClearAllShapesOnMap(map); break; case "Pan": default: map.EditOverlay.TrackMode = TrackMode.None; break; } } [MapActionFilter] public string GetQueryingFeatures(Map map, GeoCollection<object> args) { string featuresInJson = string.Empty; if (map != null) { Collection<EarthquakeQueryConfiguration> configurations = JsonSerializer.Deserialize<Collection<EarthquakeQueryConfiguration>>(args[0].ToString()); Collection<Feature> selectedFeatures = FilterEarthquakePoints(map, configurations); featuresInJson = InternalHelper.ConvertFeaturesToJson(selectedFeatures); Session["QueryConfiguration"] = configurations; } return featuresInJson; } [MapActionFilter] public string GetTrackFeatures(Map map, GeoCollection<object> args) { string featuresInJson = string.Empty; if (map != null) { // convert wkt to thinkgeo features Feature[] trackedFeatrues = args.Select((t) => { return new Feature(t.ToString()); }).OfType<Feature>().ToArray(); // add those features into edit overlay map.EditOverlay.Features.Clear(); foreach (Feature item in trackedFeatrues) { map.EditOverlay.Features.Add(item); } // restore other query conditions from session. Collection<EarthquakeQueryConfiguration> queryConfigurations = new Collection<EarthquakeQueryConfiguration>(); if (Session["QueryConfiguration"] != null) { queryConfigurations = Session["QueryConfiguration"] as Collection<EarthquakeQueryConfiguration>; } Collection<Feature> selectedFeatures = FilterEarthquakePoints(map, queryConfigurations); featuresInJson = InternalHelper.ConvertFeaturesToJson(selectedFeatures); } return featuresInJson; } [MapActionFilter] public void SwitchMapType(Map map, GeoCollection<object> args) { if (map != null) { string mapType = args[0].ToString(); LayerOverlay earthquakeOverlay = map.CustomOverlays["EarthquakeOverlay"] as LayerOverlay; foreach (Layer layer in earthquakeOverlay.Layers) { layer.IsVisible = false; } Layer selectedLayer = earthquakeOverlay.Layers[mapType]; selectedLayer.IsVisible = true; earthquakeOverlay.Redraw(); // if Isoline layer, then display its legend. if (mapType.Equals("IsoLines Map")) { map.AdornmentOverlay.Layers["IsoLineLevelLegendLayer"].IsVisible = true; } else { map.AdornmentOverlay.Layers["IsoLineLevelLegendLayer"].IsVisible = false; } } } [MapActionFilter] public string ZoomToFeature(Map map, GeoCollection<object> args) { string identifiedFeatureBbox = string.Empty; if (map != null) { string featureId = args[0].ToString(); LayerOverlay queryResultMarkerOverlay = map.CustomOverlays["QueryResultMarkerOverlay"] as LayerOverlay; InMemoryFeatureLayer markerMemoryLayer = queryResultMarkerOverlay.Layers["MarkerMemoryLayer"] as InMemoryFeatureLayer; InMemoryFeatureLayer markerMemoryHighLightLayer = queryResultMarkerOverlay.Layers["MarkerMemoryHighLightLayer"] as InMemoryFeatureLayer; Feature currentFeature = markerMemoryLayer.InternalFeatures.FirstOrDefault(f => f.Id == featureId); markerMemoryHighLightLayer.InternalFeatures.Clear(); markerMemoryHighLightLayer.InternalFeatures.Add(currentFeature); PointShape center = currentFeature.GetShape() as PointShape; map.ZoomTo(center, map.ZoomLevelSet.GetZoomLevels()[16].Scale); queryResultMarkerOverlay.Redraw(); identifiedFeatureBbox = currentFeature.GetBoundingBox().GetWellKnownText(); } return identifiedFeatureBbox; } private void ClearAllShapesOnMap(Map Map1) { // clear the tracked shapes. LayerOverlay trackShapeOverlay = Map1.CustomOverlays["TrackShapeOverlay"] as LayerOverlay; InMemoryFeatureLayer trackShapeLayer = trackShapeOverlay.Layers["TrackShapeLayer"] as InMemoryFeatureLayer; trackShapeLayer.InternalFeatures.Clear(); trackShapeOverlay.Redraw(); LayerOverlay queryResultMarkerOverlay = Map1.CustomOverlays["QueryResultMarkerOverlay"] as LayerOverlay; // clear the queried result markers from map. InMemoryFeatureLayer markerMemoryLayer = queryResultMarkerOverlay.Layers["MarkerMemoryLayer"] as InMemoryFeatureLayer; markerMemoryLayer.InternalFeatures.Clear(); // clear the highlighted result markers. InMemoryFeatureLayer markerMemoryHighLightLayer = queryResultMarkerOverlay.Layers["MarkerMemoryHighLightLayer"] as InMemoryFeatureLayer; markerMemoryHighLightLayer.InternalFeatures.Clear(); queryResultMarkerOverlay.Redraw(); // make map back to normal mode. Map1.EditOverlay.Features.Clear(); Map1.EditOverlay.TrackMode = TrackMode.None; } private Map InitializeMap() { Map Map1 = new Map("Map1"); Map1.Width = new System.Web.UI.WebControls.Unit(100, System.Web.UI.WebControls.UnitType.Percentage); Map1.Height = new System.Web.UI.WebControls.Unit(100, System.Web.UI.WebControls.UnitType.Percentage); Map1.MapUnit = GeographyUnit.Meter; Map1.MapTools.OverlaySwitcher.Enabled = true; Map1.MapTools.OverlaySwitcher.BaseOverlayTitle = " "; // add base layers. AddBaseMapLayers(Map1); // add the earthquake layer to as the data source. AddEarthquakeLayers(Map1); // add query shape layers, like track layer, marker layer and highlight layer etc. AddQueryResultLayers(Map1); // add adorment layers AddAdormentLayers(Map1); Map1.CurrentExtent = new RectangleShape(-14503631.6805645, 7498410.41581975, -7928840.70035357, 4171879.26511785); Map1.OnClientTrackShapeFinished = "trackShapeFinished"; return Map1; } private void AddBaseMapLayers(Map Map1) { WorldMapKitWmsWebOverlay worldMapKitOverlay = new WorldMapKitWmsWebOverlay("World Map Kit"); worldMapKitOverlay.Projection = WorldMapKitProjection.SphericalMercator; Map1.CustomOverlays.Add(worldMapKitOverlay); OpenStreetMapOverlay openStreetMapOverlay = new OpenStreetMapOverlay("Open Street Map"); Map1.CustomOverlays.Add(openStreetMapOverlay); BingMapsOverlay bingMapsAerialOverlay = new BingMapsOverlay("Bing Maps Aerial", BingMapsStyle.Aerial); Map1.CustomOverlays.Add(bingMapsAerialOverlay); BingMapsOverlay bingMapsRoadOverlay = new BingMapsOverlay("Bing Maps Road", BingMapsStyle.Road); Map1.CustomOverlays.Add(bingMapsRoadOverlay); } private void AddEarthquakeLayers(Map Map1) { LayerOverlay earthquakeOverlay = new LayerOverlay("EarthquakeOverlay"); //earthquakeOverlay.TileType = TileType.SingleTile; earthquakeOverlay.IsVisibleInOverlaySwitcher = false; Map1.CustomOverlays.Add(earthquakeOverlay); ManagedProj4Projection proj4 = new ManagedProj4Projection(); proj4.InternalProjectionParametersString = ManagedProj4Projection.GetDecimalDegreesParametersString(); proj4.ExternalProjectionParametersString = ManagedProj4Projection.GetSphericalMercatorParametersString(); string dataShapefileFilePath = Server.MapPath(ConfigurationManager.AppSettings["statesPathFileName"]); EarthquakeHeatFeatureLayer heatLayer = new EarthquakeHeatFeatureLayer(new ShapeFileFeatureSource(dataShapefileFilePath)); heatLayer.HeatStyle = new HeatStyle(10, 180, "MAGNITUDE", 0, 12, 100, DistanceUnit.Kilometer); heatLayer.FeatureSource.Projection = proj4; earthquakeOverlay.Layers.Add("Heat Map", heatLayer); ShapeFileFeatureLayer pointLayer = new ShapeFileFeatureLayer(dataShapefileFilePath); pointLayer.FeatureSource.Projection = proj4; pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimpleCircleStyle(GeoColor.StandardColors.Red, 6, GeoColor.StandardColors.White, 1); pointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; pointLayer.IsVisible = false; earthquakeOverlay.Layers.Add("Regular Point Map", pointLayer); EarthquakeIsoLineFeatureLayer isoLineLayer = new EarthquakeIsoLineFeatureLayer(new ShapeFileFeatureSource(dataShapefileFilePath)); isoLineLayer.FeatureSource.Projection = proj4; isoLineLayer.IsVisible = false; earthquakeOverlay.Layers.Add("IsoLines Map", isoLineLayer); } private void AddQueryResultLayers(Map Map1) { // define the track layer. LayerOverlay trackResultOverlay = new LayerOverlay("TrackShapeOverlay"); trackResultOverlay.IsVisibleInOverlaySwitcher = false; trackResultOverlay.TileType = TileType.SingleTile; Map1.CustomOverlays.Add(trackResultOverlay); InMemoryFeatureLayer trackResultLayer = new InMemoryFeatureLayer(); trackResultLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.FromArgb(80, GeoColor.SimpleColors.LightGreen), GeoColor.SimpleColors.White, 2); trackResultLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.SimpleColors.Orange, 2, true); trackResultLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimpleCircleStyle(GeoColor.SimpleColors.Orange, 10); trackResultLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; trackResultOverlay.Layers.Add("TrackShapeLayer", trackResultLayer); // define the marker and highlight layer for markers. LayerOverlay queryResultMarkerOverlay = new LayerOverlay("QueryResultMarkerOverlay"); queryResultMarkerOverlay.IsBaseOverlay = false; queryResultMarkerOverlay.IsVisibleInOverlaySwitcher = false; queryResultMarkerOverlay.TileType = TileType.SingleTile; Map1.CustomOverlays.Add(queryResultMarkerOverlay); InMemoryFeatureLayer markerMemoryLayer = new InMemoryFeatureLayer(); markerMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimpleCircleStyle(GeoColor.SimpleColors.Gold, 8, GeoColor.SimpleColors.Orange, 1); markerMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; queryResultMarkerOverlay.Layers.Add("MarkerMemoryLayer", markerMemoryLayer); InMemoryFeatureLayer markerMemoryHighLightLayer = new InMemoryFeatureLayer(); PointStyle highLightStyle = new PointStyle(); highLightStyle.CustomPointStyles.Add(PointStyles.CreateSimpleCircleStyle(GeoColor.FromArgb(50, GeoColor.SimpleColors.Blue), 20, GeoColor.SimpleColors.LightBlue, 1)); highLightStyle.CustomPointStyles.Add(PointStyles.CreateSimpleCircleStyle(GeoColor.SimpleColors.LightBlue, 9, GeoColor.SimpleColors.Blue, 1)); markerMemoryHighLightLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = highLightStyle; markerMemoryHighLightLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20; queryResultMarkerOverlay.Layers.Add("MarkerMemoryHighLightLayer", markerMemoryHighLightLayer); } private void AddAdormentLayers(Map Map1) { // ScaleBar ScaleBarAdornmentLayer scaleBarAdormentLayer = new ScaleBarAdornmentLayer(); scaleBarAdormentLayer.XOffsetInPixel = 10; scaleBarAdormentLayer.XOffsetInPixel = 5; scaleBarAdormentLayer.UnitFamily = UnitSystem.Metric; Map1.AdornmentOverlay.Layers.Add("ScaleBarAdormentLayer", scaleBarAdormentLayer); // Isoline legend adorment layer LegendAdornmentLayer isoLevelLegendLayer = new LegendAdornmentLayer(); isoLevelLegendLayer.IsVisible = false; isoLevelLegendLayer.Width = 85; isoLevelLegendLayer.Height = 320; isoLevelLegendLayer.Location = AdornmentLocation.LowerRight; isoLevelLegendLayer.ContentResizeMode = LegendContentResizeMode.Fixed; LegendItem legendTitle = new LegendItem(); legendTitle.TextStyle = new TextStyle("Magnitude", new GeoFont("Arial", 10), new GeoSolidBrush(GeoColor.StandardColors.Black)); legendTitle.TextLeftPadding = -20; isoLevelLegendLayer.LegendItems.Add(legendTitle); // add legend title // Legend items LayerOverlay earthquakeOverlay = Map1.CustomOverlays["EarthquakeOverlay"] as LayerOverlay; EarthquakeIsoLineFeatureLayer isolineLayer = earthquakeOverlay.Layers["IsoLines|Map"] as EarthquakeIsoLineFeatureLayer; for (int i = 0; i < isolineLayer.IsoLineLevels.Count; i++) { LegendItem legendItem = new LegendItem(); legendItem.TextStyle = new TextStyle(isolineLayer.IsoLineLevels[i].ToString("f2"), new GeoFont("Arial", 10), new GeoSolidBrush(GeoColor.StandardColors.Black)); legendItem.ImageStyle = isolineLayer.LevelClassBreakStyle.ClassBreaks[i].DefaultAreaStyle; legendItem.ImageWidth = 25; isoLevelLegendLayer.LegendItems.Add(legendItem); } Map1.AdornmentOverlay.Layers.Add("IsoLineLevelLegendLayer", isoLevelLegendLayer); } private Collection<Feature> FilterEarthquakePoints(Map Map1, Collection<EarthquakeQueryConfiguration> queryConfigurations) { IEnumerable<Feature> allFeatures = new Collection<Feature>(); if (Map1.EditOverlay.Features.Count > 0) { Feature queryFeature = Feature.Union(Map1.EditOverlay.Features); BaseShape queryShape = queryFeature.GetShape(); FeatureLayer currentEarthquakeLayer = (Map1.CustomOverlays["EarthquakeOverlay"] as LayerOverlay).Layers[0] as FeatureLayer; currentEarthquakeLayer.Open(); allFeatures = currentEarthquakeLayer.FeatureSource.GetFeaturesWithinDistanceOf(queryShape, Map1.MapUnit, DistanceUnit.Meter, 1, ReturningColumnsType.AllColumns); currentEarthquakeLayer.Close(); } // filter the feature based on the query configuration. allFeatures = allFeatures.Where((f) => { bool isIncluded = true; foreach (EarthquakeQueryConfiguration item in queryConfigurations) { double columnValue = double.Parse(f.ColumnValues[item.Parameter]); if ((columnValue > item.Maximum || columnValue < item.Minimum) && columnValue > 0) // nagetive means no record. { isIncluded = false; break; } } return isIncluded; }).ToList(); // clear the original markers and add new markers. LayerOverlay queryResultMarkerOverlay = Map1.CustomOverlays["QueryResultMarkerOverlay"] as LayerOverlay; InMemoryFeatureLayer markerMemoryLayer = queryResultMarkerOverlay.Layers["MarkerMemoryLayer"] as InMemoryFeatureLayer; markerMemoryLayer.InternalFeatures.Clear(); foreach (Feature item in allFeatures) { markerMemoryLayer.InternalFeatures.Add(item); } queryResultMarkerOverlay.Redraw(); LayerOverlay trackShapeOverlay = Map1.CustomOverlays["TrackShapeOverlay"] as LayerOverlay; // clear the original track shapes and add the new shapes. InMemoryFeatureLayer trackShapeLayer = trackShapeOverlay.Layers["TrackShapeLayer"] as InMemoryFeatureLayer; trackShapeLayer.InternalFeatures.Clear(); foreach (Feature item in Map1.EditOverlay.Features) { trackShapeLayer.InternalFeatures.Add(item); } trackShapeOverlay.Redraw(); return new Collection<Feature>(allFeatures.ToList()); } } }
using System; using System.Collections.ObjectModel; using System.Diagnostics; using ThinkGeo.MapSuite.Core; namespace ThinkGeo.MapSuite.EarthquakeStatistics { public class EarthquakeHeatFeatureLayer : FeatureLayer { private HeatLayer heatLayer; public EarthquakeHeatFeatureLayer() : this(null) { } public EarthquakeHeatFeatureLayer(FeatureSource featureSource) : base() { FeatureSource = featureSource; } public new FeatureSource FeatureSource { get { return base.FeatureSource; } set { base.FeatureSource = value; heatLayer = new HeatLayer(value); } } public HeatStyle HeatStyle { get { return heatLayer.HeatStyle; } set { heatLayer.HeatStyle = value; } } protected override void DrawCore(GeoCanvas canvas, Collection<SimpleCandidate> labelsInAllLayers) { try { heatLayer.Draw(canvas, labelsInAllLayers); } catch (Exception ex) { Debug.WriteLine(ex.Message); } } } }
using System.Collections.Generic; using System.Collections.ObjectModel; using System.Linq; using ThinkGeo.MapSuite.Core; using System.Globalization; namespace ThinkGeo.MapSuite.EarthquakeStatistics { public class EarthquakeIsoLineFeatureLayer : FeatureLayer { private DynamicIsoLineLayer isoLineLayer; private ClassBreakStyle levelClassBreakStyle; public EarthquakeIsoLineFeatureLayer() : this(null) { } public EarthquakeIsoLineFeatureLayer(ShapeFileFeatureSource featureSource) { FeatureSource = featureSource; } public new FeatureSource FeatureSource { get { return base.FeatureSource; } set { base.FeatureSource = value; Initialize(); } } public Collection<double> IsoLineLevels { get { return isoLineLayer.IsoLineLevels; } } public ClassBreakStyle LevelClassBreakStyle { get { return levelClassBreakStyle; } } protected override void DrawCore(GeoCanvas canvas, Collection<SimpleCandidate> labelsInAllLayers) { isoLineLayer.Draw(canvas, labelsInAllLayers); } private void Initialize() { Collection<GeoColor> levelAreaColors = new Collection<GeoColor>(); levelAreaColors.Add(GeoColor.FromHtml("#FFFFBE")); levelAreaColors.Add(GeoColor.FromHtml("#FDFF9E")); levelAreaColors.Add(GeoColor.FromHtml("#FDFF37")); levelAreaColors.Add(GeoColor.FromHtml("#FDDA04")); levelAreaColors.Add(GeoColor.FromHtml("#FFA701")); levelAreaColors.Add(GeoColor.FromHtml("#FF6F02")); levelAreaColors.Add(GeoColor.FromHtml("#EC0000")); levelAreaColors.Add(GeoColor.FromHtml("#B90000")); levelAreaColors.Add(GeoColor.FromHtml("#850100")); levelAreaColors.Add(GeoColor.FromHtml("#620001")); levelAreaColors.Add(GeoColor.FromHtml("#450005")); levelAreaColors.Add(GeoColor.FromHtml("#2B0804")); FeatureSource.Open(); Dictionary<PointShape, double> dataPoints = GetDataPoints(); GridInterpolationModel interpolationModel = new InverseDistanceWeightedGridInterpolationModel(3, double.MaxValue); isoLineLayer = new DynamicIsoLineLayer(dataPoints, GetClassBreakValues(dataPoints.Values, 12), interpolationModel, IsoLineType.ClosedLinesAsPolygons); levelClassBreakStyle = new ClassBreakStyle(isoLineLayer.DataValueColumnName); levelClassBreakStyle.ClassBreaks.Add(new ClassBreak(double.MinValue, new AreaStyle(new GeoPen(GeoColor.FromHtml("#FE6B06"), 1), new GeoSolidBrush(new GeoColor(100, levelAreaColors[0]))))); for (int i = 0; i < IsoLineLevels.Count - 1; i++) { levelClassBreakStyle.ClassBreaks.Add(new ClassBreak(IsoLineLevels[i|+ 1], new AreaStyle(new GeoPen(GeoColor.FromHtml("#FE6B06"), 1), new GeoSolidBrush(new GeoColor(100, levelAreaColors[i|+ 1]))))); } isoLineLayer.CustomStyles.Add(levelClassBreakStyle); TextStyle textStyle = TextStyles.CreateSimpleTextStyle(isoLineLayer.DataValueColumnName, "Arial", 8, DrawingFontStyles.Bold, GeoColor.StandardColors.Black, 0, 0); textStyle.HaloPen = new GeoPen(GeoColor.StandardColors.White, 2); textStyle.OverlappingRule = LabelOverlappingRule.NoOverlapping; textStyle.SplineType = SplineType.StandardSplining; textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels; textStyle.TextLineSegmentRatio = 9999999; textStyle.FittingLineInScreen = true; textStyle.SuppressPartialLabels = true; textStyle.NumericFormat = "{0:0.00}"; isoLineLayer.CustomStyles.Add(textStyle); } private Dictionary<PointShape, double> GetDataPoints() { return (from feature in FeatureSource.GetAllFeatures(GetReturningColumns()) where double.Parse(feature.ColumnValues["MAGNITUDE"]) > 0 select new PointShape { X = double.Parse(feature.ColumnValues["LONGITUDE"], CultureInfo.InvariantCulture), Y = double.Parse(feature.ColumnValues["LATITIUDE"], CultureInfo.InvariantCulture), Z = double.Parse(feature.ColumnValues["MAGNITUDE"], CultureInfo.InvariantCulture) }).ToDictionary(point => point, point => point.Z); } private static Collection<double> GetClassBreakValues(IEnumerable<double> values, int count) { Collection<double> result = new Collection<double>(); double[] sortedValues = values.OrderBy(v => v).ToArray(); int classCount = sortedValues.Length / count; for (var i = 1; i < count; i++) { result.Add(sortedValues[i|* classCount]); } return result; } private static IEnumerable<string> GetReturningColumns() { yield return "LONGITUDE"; yield return "LATITIUDE"; yield return "MAGNITUDE"; } } }
$(document).ready(function () { initializePageElements(); // Map display type $("#divBasemaps input[type='image']").bind("click", function () { Map1.ajaxCallAction("default", "SwitchMapType", { command: $(this).attr("command") }, function () { Map1.getAdornmentOverlay().redraw(true); Map1.getLayer("EarthquakeOverlay").redraw(true); }); }); $("#btnPanMap").bind("click", function () { $("#divTrackShapes input[type=image]").not($(this)).removeClass("active"); }); $("#btnClearAll").bind("click", function () { $("#divTrackShapes input[type=image]").not($("#btnPanMap")).removeClass("active"); $("#btnPanMap").addClass("active"); Map1.setDrawMode("Normal"); Map1.getEditOverlay().removeAllFeatures(); Map1.ajaxCallAction("default", "SetDrawMode", { command: "ClearAll" }, function () { Map1.getLayer('EarthquakeOverlay').redraw(true); Map1.getLayer('TrackShapeOverlay').redraw(true); Map1.getLayer('QueryResultMarkerOverlay').redraw(true); $("#resultTable tr:gt(0)").remove(); }); }); // Configuration slider var filterEarthquakePoints = function () { var queryItems = []; var magnitude = { "name": "MAGNITUDE", "min": $("#sliderFortxbMagnitude").slider("values", 0), "max": $("#sliderFortxbMagnitude").slider("values", 1) }; queryItems.push(magnitude); var depth = { "name": "DEPTH_KM", "min": $("#sliderFortxbDepth").slider("values", 0), "max": $("#sliderFortxbDepth").slider("values", 1) }; queryItems.push(depth); var year = { "name": "YEAR", "min": $("#sliderFortxbYear").slider("values", 0), "max": $("#sliderFortxbYear").slider("values", 1) }; queryItems.push(year); $("#loading").show(); Map1.ajaxCallAction("default", "GetQueryingFeatures", { "configs": JSON.stringify(queryItems) }, displayQueryResult); } var displaySlideValue = function (element, ui) { var valueSpans = $(element).parent().parent().find("span"); $(valueSpans[0]).text(ui.values[0]); $(valueSpans[1]).text(ui.values[1]); } $("#sliderFortxbMagnitude").slider({ range: true, min: 0, max: 12, values: [0,|12], stop: filterEarthquakePoints, slide: function (event, ui) { displaySlideValue(this, ui); } }); $("#sliderFortxbDepth").slider({ range: true, min: 0, max: 300, values: [0,|300], stop: filterEarthquakePoints, slide: function (event, ui) { displaySlideValue(this, ui); } }); $("#sliderFortxbYear").slider({ range: true, min: 1568, max: 2012, values: [1568,|2012], stop: filterEarthquakePoints, slide: function (event, ui) { displaySlideValue(this, ui); } }); }); function initializePageElements() { var resizeElementHeight = function () { var documentheight = $(window).height(); var contentDivH = documentheight - $("#footer").height() - $("#header").height() - 1; $("#content-container").height(contentDivH + "px"); $("#leftContainer").height(contentDivH + "px"); $("#map-content").height(contentDivH + "px"); $("#toggle").css("line-height", contentDivH + "px"); var mapDivH = contentDivH - $("#resultContainer").height(); $("#mapContainer").height(mapDivH + "px"); // refresh the map. Map1.updateSize(); } window.onload = resizeElementHeight(); $(window).resize(resizeElementHeight); // set the toggle style for group buttons $("#divTrackShapes input[type=image]").bind("click", function () { var btnImgs = $("#divTrackShapes input[type=image]"); for (var i = 0; i < btnImgs.length; i++) { $(btnImgs[i]).attr("class", ""); } $(this).attr("class", "active"); }); // Bind toggle button events $("#toggle img").bind("click", function () { if ($("#leftContainer").is(':visible')) { $("#map-content").css("width", "99%"); $("#resultContainer").css("width", "99%"); $("#toggle").css("left", "5px"); $("#leftContainer").hide(); $("#collapse").attr("src", "Images/expand.gif"); } else { $("#leftContainer").show(); $("#map-content").css("width", "80%"); $("#resultContainer").css("width", "80%"); $("#toggle").css("left", "20%"); $("#collapse").attr("src", "Images/collapse.gif"); } resizeElementHeight(); }); } var OnMapCreated = function (map) { map.events.register("mousemove", map, function (e) { var mouseCoordinate = this.getLonLatFromPixel(new OpenLayers.Pixel(e.clientX, e.clientY)); if (mouseCoordinate) { $("#spanMouseCoordinate").text("X:" + mouseCoordinate.lon.toFixed(2) + " Y: " + mouseCoordinate.lat.toFixed(2)); } }); } function displayQueryResult(result) { // Refresh the corresponding Layer var markOverlay = Map1.getOpenLayersMap().getLayer("QueryResultMarkerOverlay"); markOverlay.redraw(true); // remove all the lines except the header $("#resultTable tr:gt(0)").remove(); // Display data in the Grid table var queryItems = JSON.parse(result.get_responseData()); for (var i = 0; i < queryItems.length; i++) { var columns = queryItems[i].values; var featureId = queryItems[i].id; var newRow = $("<tr>"); newRow.append('<td><input type="image" id="' + featureId + '" src="/Content/Images/find.png" onclick="zoomToFeature(this)" /></td>'); newRow.append("<td>" + columns[0].Value + "</td>"); newRow.append("<td>" + columns[2].Value + "</td>"); newRow.append("<td>" + columns[3].Value + "</td>"); newRow.append("<td>" + (columns[4].Value < 0 ? "Unknown" : columns[4].Value) + "</td>"); newRow.append("<td>" + (columns[5].Value < 0 ? "Unknown" : columns[5].Value) + "</td>"); newRow.append("<td>" + columns[1].Value + "</td>"); $("#resultTable > tbody:last").append(newRow); } $("#loading").hide(); } function zoomToFeature(element) { Map1.ajaxCallAction("default", "ZoomToFeature", { featureId: $(element).attr("id") }, function (result) { if (result.get_responseData()) { var wkt = result.get_responseData(); var bbox = OpenLayers.Geometry.fromWKT(wkt).getBounds(); Map1.zoomToExtent(bbox); } }); } function trackShapeFinished(e) { var features = JSON.parse(e.features); var wkts = []; for (var i = 0; i < features.length; i++) { wkts.push(features[i].wkt); } $("#loading").show(); Map1.ajaxCallAction("default", "GetTrackFeatures", wkts, displayQueryResult); } // Override to support showing the drawing radius of circle var OnMapCreating = function (map) { var msDrawCircleLineId = ""; var msDrawCircleLabelId = ""; OpenLayers.Handler.RegularPolygon.prototype.move = function (evt) { var maploc = this.map.getLonLatFromPixel(evt.xy); var point = new OpenLayers.Geometry.Point(maploc.lon, maploc.lat); if (this.irregular) { var ry = Math.sqrt(2) * Math.abs(point.y - this.origin.y) / 2; this.radius = Math.max(this.map.getResolution() / 2, ry); } else if (this.fixedRadius) { this.origin = point; } else { this.calculateAngle(point, evt); this.radius = Math.max(this.map.getResolution() / 2, point.distanceTo(this.origin)); } this.modifyGeometry(); if (this.irregular) { var dx = point.x - this.origin.x; var dy = point.y - this.origin.y; var ratio; if (dy == 0) { ratio = dx / (this.radius * Math.sqrt(2)); } else { ratio = dx / dy; } this.feature.geometry.resize(1, this.origin, ratio); this.feature.geometry.move(dx / 2, dy / 2); } this.layer.drawFeature(this.feature, this.style); // if it's circle, added the drawing distance and radius if (!this.irregular) { var pointArray = []; pointArray.push(this.origin); pointArray.push(point); if (msDrawCircleLineId != "" && this.layer.getFeatureById(msDrawCircleLineId)) { this.layer.removeFeatures([this.layer.getFeatureById(msDrawCircleLineId)]); } if (msDrawCircleLabelId != "" && this.layer.getFeatureById(msDrawCircleLabelId)) { this.layer.removeFeatures([this.layer.getFeatureById(msDrawCircleLabelId)]); } var radiusLine = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LineString(pointArray), null, this.style); msDrawCircleLineId = radiusLine.id; this.layer.addFeatures([radiusLine]); var radiusLabelText = ""; var radiusLength = radiusLine.geometry.getGeodesicLength(this.layer.map.getProjectionObject()); var inPerDisplayUnit = OpenLayers.INCHES_PER_UNIT["mi"]; if (inPerDisplayUnit) { var inPerMapUnit = OpenLayers.INCHES_PER_UNIT["m"]; radiusLength *= (inPerMapUnit / inPerDisplayUnit); } radiusLabelText = parseFloat(radiusLength).toFixed(4).toString() + 'mi'; point.distanceTo(this.origin).toString() var radiusLabelFeature = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(point.x + 0.1 * this.layer.map.getExtent().getHeight(), point.y - 0.1 * this.layer.map.getExtent().getHeight()), {}, { label: radiusLabelText }); msDrawCircleLabelId = radiusLabelFeature.id; this.layer.addFeatures([radiusLabelFeature]); } } }
using System.Runtime.Serialization; namespace ThinkGeo.MapSuite.EarthquakeStatistics { [DataContract] public class EarthquakeQueryConfiguration { private string parameter; private int minimum; private int maximum; public EarthquakeQueryConfiguration() { } [DataMember(Name|= "name")] public string Parameter { get { return parameter; } set { parameter = value; } } [DataMember(Name|= "min")] public int Minimum { get { return minimum; } set { minimum = value; } } [DataMember(Name|= "max")] public int Maximum { get { return maximum; } set { maximum = value; } } } }
using System.Collections.Generic; using System.Runtime.Serialization; using ThinkGeo.MapSuite.Core; namespace ThinkGeo.MapSuite.EarthquakeStatistics { [DataContract] public class JsonFeature { private string id; private string wkt; private Dictionary<string, string> values; public JsonFeature() { } public JsonFeature(Feature feature) : this(feature.Id, feature.GetWellKnownText(), feature.ColumnValues) { } public JsonFeature(string id, string wkt, Dictionary<string, string> values) { this.id = id; this.wkt = wkt; this.values = values; } [DataMember(Name|= "id")] public string Id { get { return id; } set { id = value; } } [DataMember(Name|= "wkt")] public string Wkt { get { return wkt; } set { wkt = value; } } [DataMember(Name|= "values")] public Dictionary<string, string> Values { get { return values; } set { values = value; } } } }
using System.Collections.Generic; using System.Collections.ObjectModel; using System.Data; using ThinkGeo.MapSuite.Core; namespace ThinkGeo.MapSuite.EarthquakeStatistics { public static class InternalHelper { public static DataTable GetQueriedResultTableDefination() { DataTable tableDefination = new DataTable(); tableDefination.Columns.Add("id"); tableDefination.Columns.Add("year"); tableDefination.Columns.Add("longitude"); tableDefination.Columns.Add("latitude"); tableDefination.Columns.Add("depth_km"); tableDefination.Columns.Add("magnitude"); tableDefination.Columns.Add("location"); return tableDefination; } public static string ConvertFeaturesToJson(IEnumerable<Feature> features) { Collection<JsonFeature> jsonFeatures = new Collection<JsonFeature>(); foreach (Feature feature in features) { // re-order the columns for display it in query table Dictionary<string, string> orderedColumns = new Dictionary<string, string>(); orderedColumns.Add("year", feature.ColumnValues["YEAR"]); orderedColumns.Add("longitude", feature.ColumnValues["LONGITUDE"]); orderedColumns.Add("latitude", feature.ColumnValues["LATITIUDE"]); orderedColumns.Add("depth_km", feature.ColumnValues["DEPTH_KM"]); orderedColumns.Add("magnitude", feature.ColumnValues["magnitude"]); orderedColumns.Add("location", feature.ColumnValues["LOCATION"]); JsonFeature jsonFeature = new JsonFeature(feature.Id, feature.GetWellKnownText(), orderedColumns); jsonFeatures.Add(new JsonFeature(feature)); } return JsonSerializer.Serialize<Collection<JsonFeature>>(jsonFeatures); } } }
using System; using System.IO; using System.Runtime.Serialization.Json; using System.Text; namespace ThinkGeo.MapSuite.EarthquakeStatistics { /// <summary> /// Helper class to serialize or deserialize a generic object to/from JSON. /// </summary> public class JsonSerializer { /// <summary> /// Serializes an object to JSON /// </summary> /// <typeparam name="T">Type of object to serialize</typeparam> /// <param name="obj">Instance of object to serialize</param> /// <returns>JSON string</returns> public static string Serialize<T>(T obj) { DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType()); MemoryStream ms = new MemoryStream(); serializer.WriteObject(ms, obj); string retVal = Encoding.Default.GetString(ms.ToArray()); ms.Dispose(); return retVal; } /// <summary> /// Deserialize an object from JSON /// </summary> /// <typeparam name="T">Type of object to deserialize</typeparam> /// <param name="json">JSON string to deserialize</param> /// <returns>deserialized object</returns> public static T Deserialize<T>(string json) { T obj = Activator.CreateInstance<T>(); MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(json)); DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType()); obj = (T)serializer.ReadObject(ms); ms.Close(); ms.Dispose(); return obj; } } }
@using ThinkGeo.MapSuite.Core @using ThinkGeo.MapSuite.MvcEdition @using ThinkGeo.MapSuite.EarthquakeStatistics @model ThinkGeo.MapSuite.MvcEdition.Map @{ ViewBag.Title = "US Earthquake Statistics"; } <div id="container"> <div id="header"> <div id="left-header"> <span id="header-mapsuite">Map Suite</span> <span id="header-title">US Earthquake Statistic</span> </div> </div> <div id="content-container"> <div id="leftContainer"> <div id="leftContent"> <h4> Display Type:</h4> <div id="divBasemaps"> <input type="image" id="btnHeatMap" src="@Url.Content("~/Content/Images/heatMap.png")" command="Heat Map" /> <input type="image" id="btnPointMap" src="@Url.Content("~/Content/Images/pointMap.png")" command="Regular Point Map" /> <input type="image" id="btnIsolineMap" src="@Url.Content("~/Content/Images/Isoline.png")" command="IsoLines Map" /> </div> <div id="divblueBanner"> Earthquake Information Explorer </div> <h4> Query Tool:</h4> <div id="divTrackShapes" class="divBorder"> <input type="image" id="btnPanMap" title="Pan the map" src="@Url.Content("~/Content/Images/Pan.png")" class="active" onclick="Map1.setDrawMode('normal');" /> <input type="image" id="btnDrawPolygon" title="Draw a polygon" src="@Url.Content("~/Content/Images/DrawPolygon.png")" onclick="Map1.setDrawMode('Polygon');" /> <input type="image" id="btnDrawRectangle" title="Draw a rectangle" src="@Url.Content("~/Content/Images/DrawRectangle.png")" onclick="Map1.setDrawMode('Rectangle');"/> <input type="image" id="btnDrawCircle" title="Draw a circle" src="@Url.Content("~/Content/Images/Drawcircle.png")" onclick="Map1.setDrawMode('Circle');"/> <input type="image" id="btnClearAll" title="Clear all" src="@Url.Content("~/Content/Images/clear.png")" command="ClearAll"/> </div> <h4> Query Configuration:</h4> <div id="divQueryPanel" class="divBorder"> <table> <tr> <td colspan="3"> <h5> Magnitude: </h5> </td> </tr> <tr> <td class="cfgRangeTitle"> <span>0</span> </td> <td class="slider"> <div id="sliderFortxbMagnitude"> </div> </td> <td class="cfgRangeTitle"> <span>12</span> </td> </tr> <tr> <td colspan="3"> <h5> Depth of Hypocenter(Km): </h5> </td> </tr> <tr> <td class="cfgRangeTitle"> <span>0</span> </td> <td class="slider"> <div id="sliderFortxbDepth"> </div> </td> <td class="cfgRangeTitle"> <span>300</span> </td> </tr> <tr> <td colspan="3"> <h5> Date(Year): </h5> </td> </tr> <tr> <td class="cfgRangeTitle"> <span>1568</span> </td> <td class="slider"> <div id="sliderFortxbYear"> </div> </td> <td class="cfgRangeTitle"> <span>2010</span> </td> </tr> </table> </div> </div> </div> <div id="toggle"> <img alt="collapse" id="collapse" src="@Url.Content("~/Content/Images/collapse.gif")" /> </div> <div id="map-content"> <div id="mapContainer"> @{ Html.ThinkGeo().Map(Model).Render(); } </div> <div id="resultContainer"> <div class="grid-contianer"> <table id="resultTable"> <tr> <td class="result-header"> </td> <td class="result-header"> Year </td> <td class="result-header"> Longitude </td> <td class="result-header"> Latitude </td> <td class="result-header"> Depth(KM) </td> <td class="result-header"> Magnitude </td> <td class="result-header"> Location </td> </tr> </table> </div> </div> </div> </div> <div id="footer"> <span id="spanMouseCoordinate"></span> </div> </div> <div id="loading"> <img id="loading-image" src="@Url.Content("Content/Images/loading.gif")" alt="Loading..." /> </div>