<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="ThinkGeo.MapSuite.EarthquakeStatistics._Default" %>
<%@ Register Assembly="WebEdition" Namespace="ThinkGeo.MapSuite.WebEdition" TagPrefix="cc1" %>
US Earthquake Statistic
====Default.aspx.cs====
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web.UI;
using System.Web.UI.WebControls;
using ThinkGeo.MapSuite.Core;
using ThinkGeo.MapSuite.WebEdition;
namespace ThinkGeo.MapSuite.EarthquakeStatistics
{
public partial class _Default : Page, ICallbackEventHandler
{
private string callbackResult;
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
InitializeMap();
// display an empty query result table.
DisplayQueryResult(new Collection());
}
}
protected void ChangeTrackShapeMode_Command(object sender, CommandEventArgs e)
{
switch (e.CommandArgument.ToString())
{
case "DrawCircle":
Map1.EditOverlay.TrackMode = TrackMode.Circle;
break;
case "DrawRectangle":
Map1.EditOverlay.TrackMode = TrackMode.Rectangle;
break;
case "DrawPolygon":
Map1.EditOverlay.TrackMode = TrackMode.Polygon;
break;
case "ClearAll":
ClearQueryResult();
break;
case "Pan":
default:
Map1.EditOverlay.TrackMode = TrackMode.None;
break;
}
}
protected void rptQueryResultItemDataBound(object sender, RepeaterItemEventArgs e)
{
if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
{
var featureID = ((DataRowView)e.Item.DataItem)[0].ToString();
ImageButton update = (ImageButton)e.Item.FindControl("find");
update.CommandArgument = featureID;
}
}
protected void ibtnZoomToFeature(object source, RepeaterCommandEventArgs e)
{
string featureId = ((ImageButton)(((RepeaterCommandEventArgs)(e)).CommandSource)).CommandArgument;
ZoomToFeature(featureId);
}
protected void Map1_TrackShapeFinished(object sender, EventArgs e)
{
Collection queryConfigurations = new Collection();
if (Session["QueryConfiguration"] != null)
{
queryConfigurations = Session["QueryConfiguration"] as Collection;
}
Collection selectedFeatures = FilterEarthquakePoints(queryConfigurations);
DisplayQueryResult(selectedFeatures);
}
public string GetCallbackResult()
{
return callbackResult;
}
public void RaiseCallbackEvent(string eventArgument)
{
CallbackRequest callbackRequest = JsonSerializer.Deserialize(eventArgument);
switch (callbackRequest.Command)
{
case "Query":
IEnumerable selectedFeatures = FilterEarthquakePoints(callbackRequest.QueryConfigurations);
Session["QueryConfiguration"] = callbackRequest.QueryConfigurations;
callbackResult = InternalHelper.ConvertFeaturesToJson(selectedFeatures);
break;
case "ZoomToFeature":
callbackResult = ZoomToFeature(callbackRequest.FeatureId);
break;
case "ChangeType":
ChangeMapDisplayType(callbackRequest.MapDisplayType);
break;
default:
break;
}
}
private void ChangeMapDisplayType(string mapType)
{
LayerOverlay earthquakeOverlay = Map1.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"))
{
Map1.AdornmentOverlay.Layers["IsoLineLevelLegendLayer"].IsVisible = true;
}
else
{
Map1.AdornmentOverlay.Layers["IsoLineLevelLegendLayer"].IsVisible = false;
}
}
private void ClearQueryResult()
{
// clear the query result table.
DisplayQueryResult(new Collection());
// 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 string ZoomToFeature(string featureId)
{
LayerOverlay queryResultMarkerOverlay = Map1.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;
Map1.ZoomTo(center, Map1.ZoomLevelSet.GetZoomLevels()[16].Scale);
queryResultMarkerOverlay.Redraw();
return currentFeature.GetBoundingBox().GetWellKnownText();
}
private Collection FilterEarthquakePoints(Collection queryConfigurations)
{
IEnumerable allFeatures = new Collection();
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(allFeatures.ToList());
}
private void DisplayQueryResult(IEnumerable features)
{
DataTable resultTable = InternalHelper.GetQueriedResultTableDefination();
foreach (Feature point in features)
{
DataRow dataRow = resultTable.NewRow();
dataRow["id"] = point.Id;
dataRow["year"] = point.ColumnValues["YEAR"];
dataRow["longitude"] = point.ColumnValues["LONGITUDE"];
dataRow["latitude"] = point.ColumnValues["LATITIUDE"];
dataRow["depth_km"] = point.ColumnValues["DEPTH_KM"];
dataRow["magnitude"] = point.ColumnValues["MAGNITUDE"];
dataRow["location"] = point.ColumnValues["LOCATION"];
resultTable.Rows.Add(dataRow);
}
rptQueryResult.DataSource = resultTable;
rptQueryResult.DataBind();
}
private void InitializeMap()
{
Map1.MapUnit = GeographyUnit.Meter;
Map1.MapTools.OverlaySwitcher.Enabled = true;
Map1.MapTools.OverlaySwitcher.BaseOverlayTitle = " ";
// add base layers.
AddBaseMapLayers();
// add the earthquake layer to as the data source.
AddEarthquakeLayers();
// add query shape layers, like track layer, marker layer and highlight layer etc.
AddQueryResultLayers();
// add adorment layers
AddAdormentLayers();
Map1.CurrentExtent = new RectangleShape(-14503631.6805645, 7498410.41581975, -7928840.70035357, 4171879.26511785);
}
private void AddBaseMapLayers()
{
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()
{
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()
{
// 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()
{
// ScaleBar
ScaleBarAdornmentLayer scaleBarAdormentLayer = new ScaleBarAdornmentLayer();
scaleBarAdormentLayer.XOffsetInPixel = 10;
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].CustomStyles[0];
legendItem.ImageWidth = 25;
isoLevelLegendLayer.LegendItems.Add(legendItem);
}
Map1.AdornmentOverlay.Layers.Add("IsoLineLevelLegendLayer", isoLevelLegendLayer);
}
}
}
====ready-functions.js====
$(document).ready(function () {
initializePageElements();
// Map display type
$("#divBasemaps input[type='image']").bind("click", function () {
var args = { "command": "ChangeType", "mapType": $(this).attr("alt") };
$DoCallback(args, function (result) {
var map = Map1.GetOpenLayersMap();
var adornmentOverlay = map.getLayersByName("AdornmentOverlay");
adornmentOverlay[0].redraw(true);
var earthquakeOverlay = map.getLayer("EarthquakeOverlay");
earthquakeOverlay.redraw(true);
$("#loading").hide();
})
return false;
});
$("#btnClearAll").bind("click", function () {
$("#divTrackShapes input[type=image]").not($("#btnPanMap")).removeClass("active");
$("#btnPanMap").addClass("active");
});
// Configuration silder
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);
var args = { "command": "Query", "configs": queryItems };
$DoCallback(args, 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: 2010,
values: [1568,|2010],
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.GetOpenLayersMap().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();
});
// Make sure the resize method take effect when doing ajax call
Sys.Application.remove_load(resizeElementHeight);
Sys.Application.add_load(resizeElementHeight);
// Add the loading image.
var pageManager = Sys.WebForms.PageRequestManager.getInstance();
pageManager.add_beginRequest(function () {
$("#loading").show();
});
pageManager.add_endRequest(function () {
$("#loading").hide();
});
}
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);
for (var i = 0; i < queryItems.length; i++) {
var columns = queryItems[i].values;
var featureId = queryItems[i].id;
var newRow = $("");
newRow.append('" + columns[0].Value + " ");
newRow.append("" + columns[2].Value + " ");
newRow.append("" + columns[3].Value + " ");
newRow.append("" + (columns[4].Value < 0 ? "Unknown" : columns[4].Value) + " ");
newRow.append("" + (columns[5].Value < 0 ? "Unknown" : columns[5].Value) + " ");
newRow.append("" + columns[1].Value + " ");
$("#resultTable > tbody:last").append(newRow);
}
$("#loading").hide();
}
function zoomToFeature(element) {
var args = { "command": "ZoomToFeature", "featureId": $(element).attr("id") };
$DoCallback(args, function (result) {
if (result) {
var map = Map1.GetOpenLayersMap();
map.zoomToExtent(OpenLayers.Geometry.fromWKT(result).getBounds());
}
})
}
function $DoCallback(arg, callbackEvent, context) {
$("#loading").show();
WebForm_DoCallback("__Page", JSON.stringify(arg), callbackEvent, context, null, false);
}
// 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]);
}
}
}
====CallbackRequest.cs====
using System.Collections.ObjectModel;
using System.Runtime.Serialization;
namespace ThinkGeo.MapSuite.EarthquakeStatistics
{
[DataContract]
public class CallbackRequest
{
private string mapType;
private string command;
private string featureId;
private Collection queryConfigrations;
public CallbackRequest()
{ }
[DataMember(Name|= "command")]
public string Command
{
get { return command; }
set { command = value; }
}
[DataMember(Name|= "mapType")]
public string MapDisplayType
{
get { return mapType; }
set { mapType = value; }
}
[DataMember(Name|= "featureId")]
public string FeatureId
{
get { return featureId; }
set { featureId = value; }
}
[DataMember(Name|= "configs")]
public Collection QueryConfigurations
{
get
{
if (queryConfigrations == null)
{
queryConfigrations = new Collection();
}
return queryConfigrations;
}
internal set { queryConfigrations = value; }
}
}
}
====EarthquakeHeatFeatureLayer.cs====
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 labelsInAllLayers)
{
try
{
heatLayer.Draw(canvas, labelsInAllLayers);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
}
====EarthquakeIsoLineFeatureLayer.cs====
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 Collection levelAreaColors;
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 IsoLineLevels
{
get
{
Collection result = null;
if (isoLineLayer != null)
{
result = isoLineLayer.IsoLineLevels;
}
return result;
}
}
public Collection LevelAreaColors
{
get
{
if (levelAreaColors == null)
{
levelAreaColors = new Collection();
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"));
}
return levelAreaColors;
}
}
public ClassBreakStyle LevelClassBreakStyle
{
get
{
if (levelClassBreakStyle == null)
{
levelClassBreakStyle = new ClassBreakStyle(isoLineLayer.DataValueColumnName);
Collection