ThinkGeo and Map Suite White Papers

Integrating Map Suite with SQL Reporting Services

ThinkGeo — Wed, 05 Nov 2008 08:53:39 GMT

This article will show you how to combine data-driven reports and location-driven spatial information, by using Map Suite in concert with SQL Reporting Services. In the included example, we'll build a report and then display its data thematically on a map of the United States with Map Suite Web Edition. The article is based on Map Suite Web version 1.1 and Microsoft SQL Reporting Services with SP1 applied.

Download code for this article

Introduction

Today many developers are turning to Microsoft SQL Reporting Services™ to deliver great looking reports for their end users. And while having a professional looking report containing tabular data is great, sometimes users demand a more graphical representation of the data such as a chart or a map.

In this article we will step through the process of building a report based on data included in the AdventureWorks2000 database that is installed with SQL Reporting Services. Once we have a sales report showing the sales data, we will add a map of the United States displaying the sales data thematically by state.

(Note: This article covers the Webforms Edition of Map Suite version 1.1 and Microsoft SQL Reporting Services with SP1 applied. You will also need to have the AdventureWorks2000 sample database installed as well as Visual Studio 2003 and the .NET Framework v1.1. You can download the trial version of Map Suite Webforms Edition by following the link below. A short simple registration is required.)

Getting Started

After you have downloaded and installed the trial version of Map Suite, open Visual Studio.NET, let's get started by creating a new reporting project called MappingReports. To do this open up Visual Studio and click File, New Project and choose Report Project from the Business Intelligence Projects folder. Go ahead and name the project MappingReports and click OK.

Next, let's setup the shared data source to the AvdentureWorks2000 database. To do this you can right mouse button click on the Shared Data Sources folder underneath your MappingReports project and choose Add New Data source. This will prompt you with the following screen. Go ahead and set your connection properties and click OK.

Building the Report

Now that we have the data source setup, we can add the report and retrieve our sales data. Right mouse button click on the Reports folder under the MappingReports project and choose Add New Report. This will start the new report wizard. Click next to begin. The second screen will prompt you to select a data source. Choose AdventureWorks2000 and click the Next button. Next we will be prompted to design the query to return the report data. We will use the query below to retrieve the total sales amount, orders count and customer count for each state from the AdventureWorks2000 database. Enter the following query and click the Next button:

SELECT s.Name AS 'State', Sum(o.TotalDue) AS 'TotalSalesAmt', Count(c.CustomerID) AS 'OrderCount', Count(Distinct c.CustomerID) AS 'CustomerCount'
FROM Customer c JOIN CustomerAddress ca ON c.CustomerID = ca.CustomerID
JOIN Address a ON ca.AddressID = a.AddressID
JOIN StateProvince s ON a.StateProvinceID = s.StateProvinceID
JOIN SalesOrderHeader o ON c.CustomerID = o.CustomerID
WHERE s.CountryRegionCode = 'US' GROUP BY s.Name

Now we need to select a report type, for our purposes a tabular report will work the best. Choose Tabular and click the Next button:

Next we are prompted to design our table to hold the tabular data. Highlight all of the available fields and click the Details button and then click the Next button. This will display all the fields from the query into the detail section of our report:

Our next step is to give our report table a style. For this example let's choose corporate and click the Next button:

Finally we are prompted to give our report a name, let's name the report SalesReport and click the Finish button:

Now that we have a basic report created, let's do a few things to make it look a little more professional. First, we'll drag the table and heading items to a width of 6.5 inches to stop the table headings from wrapping. This will also give us plenty of room to insert the map later on. One other thing we need to do is format the TotalSalesAmt field as currency. To accomplish this, right mouse button click on the TotalSalesAmt field and choose properties. Then choose currency from the format list and click the OK button.

As one last step for setting up the report, let's create a parameter for this report so the user can select the type of map they want to see. To do this we need to make sure the report is in layout mode and then choose Report Parameters from the Report menu item. You will be prompted with a report parameters dialog box and it will need to be filled out like the picture below:

Click the Add button and put MapDisplay in the name field. Also change the prompt to say "Display Map By". Next we need to add some selectable values for this parameter so let's add the following information to the Available values section:

Label	Value
Total Sales Amt	TotalSalesAmt
Number of Orders	NumberOfOrders
Number of Customers	NumberOfCustomers

Building the Map

Now that we have the basic report setup it's time to move onto building the map. The map will be added to the report through an external URL so the first thing we need to do is create the URL that will generate the map. To do this we need to add a new ASP.NET project to our solution by clicking File, Add Project, New Project. Then choose ASP.NET Web Application under the Visual Basic Projects folder and give your web application a name of MapBuilder.

This will create a new web project with a Webform1.aspx page already added. Let's rename the Webform1.aspx page to something more meaningful by right mouse button clicking on it and changing the name to GetMap.aspx.

(NOTE: Before moving on to the next steps you will need to install the evaluation version of Map Suite Webforms Edition it can be downloaded here. A short simple registration is required.)

Now we need to add the Map Suite ASP.NET server control that will be building the map for us. To do this right mouse button click on the Web Forms tab of the control toolbox and choose Add/Remove items and then Browse to the C:\Program Files\Spatially Aware\[YOUR MAP SUITE WEBFORMS VERSION]\WebformsEdition.dll. This will add the map control to your toolbox (The Map Suite Webforms control is represented by a little icon of the world.)

The next step is to drag the map control onto the GetMap.aspx page and set the Map1.Width equal to 600px and the Map1.Height equal to 400px, this will give us the right sized map to fit into our report later on. The last thing we need to do before we can begin coding is set up the web.config entries for the Map control and the connection string to the AdventerWorks2000 database. Open up the web.config file and insert the entries below the xml tag:

In addition, add the following web.config setting defining the http handler for the map control under the system.web XML tag:

One last setup task is to add our map data to the project. To accomplish this right click on the MapBuilder project and choose Add, then Add Existing Item. Then browse to 'C:\Inetpub\wwwroot\MapSuiteVBSampleApps\SampleData\USA' and add the States.SHP, States.SHX and States.DBF files to the project. These files provide the data necessary to draw the map of the United States.

Now it's time to start coding! Let's begin by declaring some Imports statements at the top so we don't have to type all of those long namespaces. Go ahead and add the following Imports statements to the top of the GetMap.aspx code-behind page GetMap.vb. You can reach the code-behind page by double clicking on the ASPX page or by pressing the F7 function key.

Imports MapSuite
Imports MapSuite.Webforms
Imports MapSuite.Geometry
Imports System.Drawing.Imaging
Imports System.Data.SqlClient
Imports System.Drawing.Drawing2D

The first part we'll focus on is the Page_Load event of GetMap.aspx code-behind where we can enter in the code listed below:

Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
	'Put user code to initialize the page here
	Try
		'Clear the Layers so we start from scratch
		Map1.Layers.Clear()
		'Default the report type to the TotalSalesAmt
		Dim ReportType As String = "TotalSalesAmt"
		'Set the Report Type based upon the Query String passed into the URL
		If Request.QueryString.Count > 0 Then ReportType =
		Request.QueryString("ReportType").ToString
		'Set the Map Unit to Decimal Degrees because that is the unit our map data is in
		Map1.MapUnit = MapLengthUnits.DecimalDegrees
		'Load the layer defining the United States
		Dim StatesLayer As New Layer(Me.Server.MapPath("") & "\States.shp", True)
		'Call the BindSalesDataToMap() Function to load are custom sales data
		StatesLayer.CustomFields.Add(BindSalesDataToMap(ReportType))
		'Call the SetMapRendering() Routine to set the display features of the map
		SetMapRendering(StatesLayer, ReportType)
		Map1.Layers.Add(StatesLayer)
		'Set the map to only show the lower 48 states
		Map1.CurrentExtent = New RectangleR(-125, 50, -66, 23)
		'Retrieve Bitmap from the Map Control
		Dim salesMap As Bitmap = Map1.GetBitmap(CInt(Map1.Width.Value), CInt(Map1.Height.Value), False)
		'Write the JPEG of the Map Out using the Response Object
		Response.ContentType = "image/jpeg"
		Response.Charset = ""
		salesMap.Save(Response.OutputStream, ImageFormat.Jpeg)
	Catch ex As Exception
		Throw ex
	End Try
End Sub

The above code block starts out by clearing any existing layers loaded into the map. In a real world example you may want to keep the layers loaded, but for simplicity sake in this example we will just load the map from scratch each time. Next we interrogate the query string to see how we need to build the map (we will describe setting the query string parameter in the report a little later on). The next piece of code loads the States Layer object with the files State.shp file we added to our project earlier. We then pass the State layer into two routines called BindSalesDataToMap() and SetMapRendering(). These routines handle the data binding and map formatting which we will get to shortly. Finally, after all of this is completed we add the states layer to the map control and write the resulting image out using the Response object.

Binding Custom Sales Data to the Map

Now we will look in more detail on how to bind our custom sales data to the map of the United States. Before we can do any binding we must retrieve the same data that our report uses from the AdvetureWorks2000 database. We can do this by using the same SQL statement that we defined for the report earlier. With that completed all we need to do is open up a connection to the database using the connection string we defined earlier in the web.config and execute the SQL statement returning a SQLDataReader object. Now that we have our custom sales data it's time to bind it to the map. We start by dimensioning a salesData variable as a CustomField object. The CustomField object allows us to bind any custom data to an already existing map layer. In our case this is the states layer.

The binding is pretty straightforward. We first set the CustomFieldName property to what we want to name our custom data. In this case we will name it "SalesData". This allows us to reference the custom data through the Map control API just like it was included in the Map from the beginning. Next we have to set the LinkFieldName property, this property acts as the join argument between our custom data and the data inside the States layer. Since we have our custom data grouped by state name we will join it to the map using the STATE_NAME column that is a column in the States.DBF data file.

Now that we have the field name and link field setup, all we have left is to add the custom sales data. To do this we iterate through the SqlDataReader adding each row to the custom data property; setting the key equal to the state name and the value equal to the custom sales data that we selected via the report type parameter. Once this is completed we return the CustomField object from the function so it can be added to the states layer object. You can copy and paste the Function below into your GetMap.aspx page to bind the sales data to the map.

Private Function BindSalesDataToMap(ByVal ReportType As String) As CustomField
	Dim sqlConn As New SqlConnection
	(System.Configuration.ConfigurationSettings.AppSettings("connectionString"))
	Dim sqlCommand As SqlCommand
	Dim salesDataReader As SqlDataReader
	Try
		Dim sql As String = "Select s.Name as 'State', Sum(o.TotalDue) as 'TotalSalesAmt',
		Count(c.CustomerID) as 'OrderCount', " & _
		"Count(Distinct c.CustomerID) as 'CustomerCount' " & _
		"From Customer c Join CustomerAddress ca on c.CustomerID = ca.CustomerID " & _
		"JOIN Address a ON ca.AddressID = a.AddressID " & _
		"JOIN StateProvince s ON a.StateProvinceID = s.StateProvinceID " & _
		"JOIN SalesOrderHeader o ON c.CustomerID = o.CustomerID " & _
		"Where s.CountryRegionCode = 'US' GROUP BY s.Name "
		sqlConn.Open()
		sqlCommand = sqlConn.CreateCommand
		sqlCommand.CommandText = sql
		salesDataReader = sqlCommand.ExecuteReader
		'Define a Custom Field to hold our sales data
		Dim salesData As New CustomField
		salesData.CustomFieldName = "SalesData"
		'This is the field name in the states.shp that will Link us to our custom sales data
		salesData.LinkFieldName = "STATE_NAME"
		Do While salesDataReader.Read
			'Add the Custom Sales Data
			Select Case ReportType
				Case "TotalSalesAmt"
				salesData.CustomData.Add(salesDataReader("State"), FormatCurrency
				(salesDataReader
				("TotalSalesAmt")))
				Case "NumberOfOrders"
				salesData.CustomData.Add(salesDataReader("State"), salesDataReader("OrderCount"))
				Case "NumberOfCustomers"
				salesData.CustomData.Add(salesDataReader("State"), salesDataReader("CustomerCount"))
			End Select
		Loop
		Return salesData
	Catch ex As Exception
		Throw ex
	Finally
		sqlConn.Close()
	End Try
End Function

Rendering the Map

With the custom sales data included in our map, it's time to set the rendering properties so the map will display in the manner we want. First we start off be defining a Threshold. A Threshold is a mechanism to turn Layers on and off depending upon how far you are zoomed in or zoomed out of the map. In our example it is extremely simple because we always want to show the states Layer no matter what so we just define one Threshold between 0 and 10,000 miles. Next we define a Symbol Renderer that will show all the states with no sales data in a light gray color and add it to the Threshold.

(NOTE: For more information on Layers, Thresholds and Symbol Renderers see this article).

The last thing to setup in the rendering is the class breaks. Class breaks allow us to show a state in a different color depending upon its sales data. For this example we will use three different class breaks: 1) low sales, 2) medium sales and 3) high sales. This will shade the states with high sales numbers in green, medium sales in light green and low sales in light yellow. Once we have our area symbols defined for the different colors we need to decide on what values will be the class breaking points. As you can see by the case statement below, we set different break points based upon the report type parameter passed in. Finally we create the ClassBreakRenderers using the break points we set and then tie them to the custom data field we created in the BindSalesToMap() function called "SalesData". Once the ClassBreakRenderers are setup all we need to do is add them to the SymbolRenderers collection on the Threshold and then add the Threshold to the States Layer. You can copy and paste this routine into the GetMap.aspx page as well to setup the map rendering:

Private Sub SetMapRendering(ByRef StatesLayer As Layer, ByVal ReportType As String)
	'Create Threshold to Display the Map between 0 and 10,000 miles
	StatesLayer.ThresholdUnit = ThresholdUnits.miles
	Dim threshold As New Threshold(10000, 0)
	'Create Symbol Renderer to render the map in Light Gray for states with no data
	Dim symbolRenderer As New SymbolRenderer(New AreaSymbol(New Pen(Color.Black), New
	HatchBrush(HatchStyle.Percent80, Color.LightGray)))
	threshold.SymbolRenderers.Add(symbolRenderer)
	'Set Color for each of the custom sales data ranges
	Dim lowSales As New AreaSymbol(New Pen(Color.Black), New SolidBrush
	(Color.LightGoldenrodYellow))
	Dim mediumSales As New AreaSymbol(New Pen(Color.Black), New SolidBrush(Color.LightGreen))
	Dim highSales As New AreaSymbol(New Pen(Color.Black), New SolidBrush(Color.Green))
	Dim lowerBreak As Double
	Dim higherBreak As Double
	'Set the Break Values for the different Report Types
	Select Case ReportType
		Case "TotalSalesAmt"
			lowerBreak = 1000000 '1 Million
			higherBreak = 10000000 ' 10 Million
		Case "NumberOfOrders"
			lowerBreak = 100
			higherBreak = 1000
		Case "NumberOfCustomers"
			lowerBreak = 10
			higherBreak = 50
	End Select
	'Create some Class Break Renders to show different colors by state based upon sales data
	Dim salesClassBreaks As New SymbolClassBreakCollection
	'Create a Class Break for Low Sales as Light Green
	salesClassBreaks.Add(New SymbolClassBreakRenderer.ClassBreak(lowerBreak, lowSales))
	'Create a Class Break Cap For Medium and High Sales to use
	Dim ClassBreakCap As New SymbolClassBreakRenderer.ClassBreakCap(higherBreak, highSales, mediumSales)
	salesClassBreaks.Add(ClassBreakCap)
	'Tie the Class Break Renderers to our new custom field of SalesStats
	Dim salesClassBreakRenderer As New SymbolClassBreakRenderer("SalesData", salesClassBreaks)
	'Add the Class Break Renderers
	threshold.SymbolRenderers.Add(salesClassBreakRenderer)
	StatesLayer.Thresholds.Add(threshold)
End Sub

At this point we all of the code completed. Set the MapBuilder project as the startup project and set the GetMap.aspx page as the startup page for the project. You can now click the Start button or press the F5 function key to compile and execute the program. You should see your browser pop up with a map similar to the one below:

Adding the Map to the Report

With most of the work behind us, let's now go back to the report and add the map in. Bring the sales report up in layout mode and drag the bottom of the report down some so we have a blank area to insert the map. Drag an image report item from the toolbox onto the report. This will start the image wizard. Go ahead and click the Next button to begin. The first question we have to answer is where the image is located. For this example we need to choose web option.

Next we are prompted for the URL of the image, in our case we want to put in the GetMap.aspx URL that we developed to create the map. So enter http://localhost/MapBuilder/GetMap.aspx into the URL settings box and click next.

The image wizard should successfully retrieve the map and show a screen like the one below. Go ahead and click the Finish button to add the map to the report.

After the map has been added to the report you may want to rearrange the report a little so everything fits together nicely.

Changing the Map Using Report Parameters

Now that we have our map displaying on the report the only thing left to do is change the map based upon what the user chooses from the "Display Map By" report parameter. To add this functionality, make sure your report is in layout mode and click on the image and then choose View, Properties Window from the menu bar. This will display all the properties for the image report item containing the map. The property that we are interested in is the value property. Click on the value property and choose from the drop down list. This will open the expression builder dialog which we will use to programmatically set the URL value for the image using the reports "Display Map By" report parameter. Enter the following expression into the expression area so it matches the image below.

="http://localhost/MapBuilder/GetMap.aspx?ReportType=" & Parameters!MapDisplay.Value

Click OK and change the report mode to preview. Try choosing a different value for the "Display Map By" parameter and watch some of the states change colors to representing the different sales data and class breaks. If everything was done correctly you should have a report that looks similar to the one below.

Summary

In this example we showed that with a minimal amount of code a custom map can be added to a SQL Reporting Services report. We have only scratched the surface of what is possible using mapping technology to give a graphical representation of report data. Several common features like map labeling, point plotting and spatial querying can easily be accomplished using this same type of architecture. One other thing to keep in mind is that the map can easily be changed to include a geographic area of any size. So while this example represents data across the entire United States, the map could easily be built to only display a city, county or a particular state. With end user's demand for information growing year after year, having a tool to show data in a more meaningful way is always helpful.

Other Resources

There are several other resources at ThinkGeo to help you get started to developing feature rich mapping and spatial applications for Microsoft .NET. Some of those resources are listed below. You can always reach a ThinkGeo support representative by phone toll-free at (866) 847-7510 or via email at support@thinkgeo.com.

Sample Applications

There are 35+ sample applications included with Map Suite when you download the trial version that include the source code to show you how to do various operations using the Map Suite component. It is very beneficial to go through those examples and the code. Both VB.NET and C# are included.

View the Map Suite sample applications online

Discussion Forums

The Map Suite Discussion Forums are a great place to get answers to all of your Map Suite development questions. The ThinkGeo Support Team monitors the forums daily and can help you on your way to being successful with Map Suite.

Visit the Discussion Forums online

Using the Spatial Query Capabilities of Map Suite

ThinkGeo — Wed, 05 Nov 2008 10:16:33 GMT

Map Suite has powerful spatial querying abilities. This allows you to find features of a Layer based on spatial criteria such as containment, intersection etc. This capability is built into the API of Map Suite and is easy even for the non-GIS developer to use. This article will introduce these concepts and show you how they can be accomplished with Map Suite.

Introduction

If you need to build spatial querying capabilities into your maps you can do so quickly and easily using the spatial querying capabilities built into Map Suite. This article will show you the basics of getting started on your way to building your own feature rich spatial applications.

(NOTE: This article references the SpatialQueriesApp that is available in the sample applications with both the trial and full versions of Map Suite. This article also focuses on the Winforms Edition of Map Suite but most of the concepts and all of the example code applies for the Webforms (ASP.NET) Edition as well.)

Opening the Sample Applications in Visual Studio.NET Solution

After you have downloaded and installed the full or trial version of Map Suite, you may want to look through the sample applications and source code that are included with the installation. You can view the samples by going to the START menu...All Programs...ThinkGeo...[YOUR MAP SUITE VERSION] and choose either the VB Sample Apps Source Code or C# Sample Apps Source Code menu item. This will open a solution in Visual Studio.NET that includes all of the Map Suite Sample applications as well as the source code. You may also need to add the Map Suite Map Control to your Toolbox in the Visual Studio.NET IDE. You can do this by using the Add/Remove Items feature and browsing to the winformsedition.DLL file that resides in the installation directory of Map Suite (By default this is C:\Program Files\ThinkGeo\[The Version You Have Installed]\).

Now let's take a look at spatial queries in Map Suite.

(NOTE: This article assumes the basics of loading Shape Files into Map Suite Layers. For a more detailed explanation of how to load Layers and how Map Suite uses shape data and DBF files, see the Map Suite Quick Start User's Guides.)

Why Spatial Queries?

You might be wondering why you would want to use spatial queries. Some good examples of spatial querying might be the need to know the coverage area for a Wi-Fi system or the proximity of possible hazardous materials to schools so that plans can be made accordingly. These are just a couple of examples of how spatial querying can be a powerful tool.

So let's jump right into an example using Map Suite and see how you can get started adding these features to your own applications.

Setting the Map Mode to a Track Shape

The first step in spatial querying is to allow for our user to create a shape that will be used for querying, for example using a rectangle or an ellipse. We can accomplish this by using the Mode property of the Map and one of several mode types from the ModeType Enumeration:

Map1.Mode = ModeType.TrackLine
Map1.Mode = ModeType.TrackPolygon
Map1.Mode = ModeType.TrackRectangle
Map1.Mode = ModeType.TrackCircle
Map1.Mode = ModeType.TrackEllipse

Any one of these values will change the cursor to the mode of selection indicated and allow the user to draw a shape. We now need to be able to create the shape based on what was drawn and we can do this using Map Suite's FinishedTrackShape() Event which takes an argument of type BaseShape. Example code from the SpatialQueriesApp sample application is shown below:

Private Sub Map1_FinishedTrackShape(ByVal Shape As MapSuite.Geometry.BaseShape) Handles Map1.FinishedTrackShape
	If Not Shape Is Nothing Then
		'-- After a shape is drawn, store the shape and re-run the query
		mQueryBaseShape = Shape
		Call SpatialQuery()
	End If
End Sub

The above code captures the BaseShape being passed in and assigns it to the mQueryBaseShape variable which is defined at the Class level as a BaseShape. Immediately after the SpatialQuery() method is called. Let's take a look at that method to get an idea of how Map Suite can now query the data:

Private Sub SpatialQuery()
	Dim RecordNumbers() As Integer
	Dim lyr As Layer
	Dim Index As Integer
	'-- Here we want to deselect everything on each layer
	For Each lyr In Map1.Layers
		lyr.Deselects()
	Next
	'-- Identify which layer with which to work
	If RadioButtonCounties.Checked Then
		Index = 0
	ElseIf RadioButtonRoads.Checked Then
		Index = 1
	ElseIf RadioButtonCities.Checked Then
		Index = 2
	End If
	lyr = Map1.Layers.Item(Index)
	'-- Get the record numbers returned by the query
	RecordNumbers = lyr.SpatialQuery(mQueryBaseShape, CType
	(ComboBoxSpatialRules.SelectedIndex, SpatialQueryContainment))
	'-- Select the returned items on the layer - this will highlight the
	'-- features so the user can see the query results
	lyr.Selects(RecordNumbers)
	'-- Redraw the map
	Map1.Refresh()
End Sub

There are several things occurring in the above code so let's take a look at each step in detail. We first declare an array of type Integer that will hold the record numbers returned from our query. We then declare an object of type Layer that will be used in an iteration to deselect anything that might have been set to selected in a previous query. We then declare an Index of type Integer which will be set when we determine from the user interface which Layer the user wants to query (see user interface of the SpatialQueriesApp in the sample applications).

Now that we have our variables declared we want to go ahead and iterate through all available Layers in the map and deselect anything that might be selected as mentioned above. We then check the user interface RadioButtons to see which one the user has selected. In the case of our SpatialQueriesApp sample application, it is either the Counties, Roads or Cities Layer. After we set the appropriate index, we can now get a reference to that Layer in the Map's Layer collection.

Now comes the magic. With just a simple call to the referenced Layer's SpatialQuery() method, passing in the previously populated BaseShape (mQueryBaseShape) set in the Map's FinishedTrackShape() method and a value from the SpatialQueryContainment Enumeration (NOTE: In the above code, the value is coming from a user interface ComboBox control and then it is cast specifically to type SpatialQueryContainment), an array of record numbers (Integers) is returned. You can then call the Layer's Selects() method and pass in the array. Lastly, we call the Refresh() method on the map. When we do, the appropriate items on the map that resulted from the query will be automatically highlighted, as shown below:

The SpatialQueryContainment Enumeration

Let's take a closer look at the SpatialQueryContainment Enumeration. This provides what type of query operation needs to be performed on the selected Layer features to be queried:

Operation	Result
Contained	Returns the features that fully contain the querying shape.
Containing	Returns the features that the querying shape fully or partially contains.
Fully Containing	Returns the features that the querying shape fully contains.
Containing Centroid	Returns the features whose centroid is contained by the querying shape.
Fully Outside	Returns the features that are fully outside the querying shape.
Outside	Returns the features that are fully or partially outside the querying shape.
Intersecting	Returns features that are intersected by the querying shape.

An example of each of these query operations is shown below so that you can visually see how each is represented:

(NOTE: The Query Type ComboBox provides reference for which type of query is being shown)

Summary

As you can see, it is very easy to use spatial queries in your Map Suite application. With only a few lines of code, and some representative data, you can have fully functional spatial analysis maps to your users in very little time. Remember to check out the SpatialQueriesApp sample application to see this code and other features such as traversing the map with operations like Zooming, Panning, Track Zoom etc.

Other Resources

Sample Applications

There are 40+ sample applications included with Map Suite when you download the trail version that include the source code to show you how to do various operations using the Map Suite component. It is very beneficial to go through those examples and the code. Both VB.NET and C# are included.

View the Map Suite sample applications online

Discussion Forums

Visit the Discussion Forums online

How To Use the Map Rotation Feature in Map Suite 2.53.5

ThinkGeo — Thu, 13 Nov 2008 05:48:51 GMT

After hearing many requests for Map Rotation functionality from the Map Suite user community, we decided to add that feature to Map Suite starting with version 2.53. We approached the goal of having the entire map rotate from the center of its current extent at will through a Projection class called Rotated. In other words, from the developer's perspective, Map Rotation is simply applying a Projection class to all the Layers and MapShapes, and letting Map Suite take care of everything else automatically.

Note: For the purposes of this article we have used the Map Suite Desktop Edition to demonstrate Map Rotation, but please note that Map Rotation functionality is also available in the Map Suite Web and Engine editions.

Applying Map Rotation

For the developer, applying Map Rotation is very straightforward. Essentially, all vector data (Layers and MapShapes) need to have their projection property set to the projection class Rotated. But before we do that, we need to declare a form level variable for Rotated.

Private mRotated As New MapSuite.Geometry.Rotated()

We will use mRotated as the projection for all the Layers and MapShapes of the Map. It is very important that each time you add a new Layer or MapShape to the Map, you apply the Rotated projection to it. Otherwise, the Map Rotation will not apply to that object.

For a Layer, we add it to the Map the following way:

Dim Layer1 As New Layer("..\MyLayer.shp", mRotated, False)

For a MapShape, we simply set the Projection property to Rotated:

PointMapShape1.Projection = mRotated

Now, with all the Layers and MapShapes having their Projection property set to Rotated, we are ready to have the Map Rotation take effect. Each time the map has to rotate, we use the SetAngle method of Rotated.

Map1.CurrentExtent = mRotated.SetAngle(90, Map1.CurrentExtent)

You can rotate the Map from 0 to 360 degrees counterclockwise by using positive values, or clockwise by using negative values. So for example, 90 and -270 will have the same effect.

If you want to rotate incrementally, for example by 10 degrees at a time, you can use the GetAngle property and add 10 as the Angle parameter of SetAngle. Here we are rotating the map by increment of 10 degrees counterclockwise.

Map1.CurrentExtent = mRotated.SetAngle(mRotated.GetAngle + 10, Map1.CurrentExtent)

Keeping the Bearings

As the Map rotates, it is important to keep bearings and to know where the North is. That is why drawing a North Arrow that always points to the north helps prevent you from getting disoriented. Below is a trick that can be used to draw a bitmap of a North Arrow that always points to the North.

First, declare a form level variable for the North Arrow bitmap. Then, in the AfterMapDraw event of the Map, you can write the logic for the rotation:

Private Sub Map1_AfterMapDraw(ByVal g As System.Drawing.Graphics) Handles Map1.AfterMapDraw
        Dim Matrix As New Matrix
        Dim ImageX, ImageY, ImageWidth, ImageHeight As Integer
        ImageX = 30 : ImageY = 30 : ImageWidth = 56 : ImageHeight = 69
        Dim pt As New PointF(ImageX + (ImageWidth / 2), ImageY + (ImageHeight / 2))
        Matrix.RotateAt(CSng(-mRotated.GetAngle), pt)
        g.Transform = Matrix
        g.DrawImage(mNorthArrowBitmap, ImageX, ImageY, ImageWidth, ImageHeight)
        g.Dispose()
End Sub

Fig 1: Street Map with Angle set at 0.

Fig 2: Street Map with Angle set at 132. See how the North Arrow tilted to point to the North.

In the included demo application, we show you two ways to rotate the map. One is by using a Button control where the angle of Map is changed, by a user defined increment, clockwise and counterclockwise. The other method is by using a Roll control that serves as a compass, where you can set the angle of the map using the mouse. Download the demo application to see both methods in action. (Please note that the demo requires the free evaluation of the Map Suite Desktop GIS .NET control, available here.)

Another important thing to take into account is the coordinates we get on the Map by rotating it. If we always want to have the real coordinates and not the coordinates from the rotation, we are going to use the ProjectPointBack method of Rotated. The code below will show the real coordinates from the MouseMove event on the status bar:

Private Sub Map1_MouseMove(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles Map1.MouseMove
        Dim RotWorldPointR As PointR = Map1.ToWorldCoordinate(e.X, e.Y)
        Dim RealWorldPointR As PointR = mRotated.ProjectPointBack(RotWorldPointR.X, RotWorldPointR.Y)
        StatusBar1.Panels(0).Text = "X: " & RealWorldPointR.X & "  Y: " & RealWorldPointR.Y
        StatusBar1.Panels(1).Text = DecimalDegrees.DecimalDegreesToDMS(RealWorldPointR)
End Sub

Ruminations

Taking the idea of Map Rotation further, nothing stops us from displaying the world with the North down, the South up, the East to the left and the West to the right by applying a 180 angle to the Rotated projection:

Fig 3. The World with the South on top. This map was created by applying an angle of 180 degrees to a few of the ShapeFiles that come with the Render World product.

The map shown above will probably shock many of us, but although this is an unconventional view of the world, it is completely accurate scientifically and it is not breaking any cartographic rules.

Below are the scientific definitions of the four cardinal directions:

East: The direction toward which the Earth rotates about its axis (therefore the direction from which the Sun appears to rise)

West: The direction opposite to that of the Earth's rotation axis (therefore the direction towards which the Sun appears to set)

South: The direction along the earth's surface toward the pole that is on one's right at the Equator when facing the direction toward which the Earth rotates about its axis (East).

North: The direction along the earth's surface toward the pole that is on one's left at the Equator when facing the direction toward which the Earth rotates about its axis (East).

So according to those definitions, there is no reason why the North must be placed on top. The reason it seems odd to many of us is due to our own western bias, where North has always historically been used as a fundamental direction, placing Europe on the top of the map. But this is completely arbitrary.

Even the magnetic north, which is the direction along the earth's surface in which horizontal magnetic field strength has its most positive value, is a very transitional thing. Due to the “flipping” of the magnetic poles, perhaps in a few thousand years, the magnetic pole will later lie in the southern hemisphere.

Conclusion

Map Suite developers can now take advantage of Map Rotation to add a totally new dimension of map display to their GIS applications. Currently, Map Rotation applies only to vector data, Layers and MapShapes, not ImageLayers or GRIDs. We are aware that this is a limitation. The next major release of Map Suite, version 3.0, is planned to support Map Rotation for any data, vector or raster image.

Downloads

Download Map Rotation Demo Application
Note: You will need to download the Map Suite Desktop .NET GIS Control Free Evaluation in order to run the example in this article. (Registration Required)

Have Questions?

Do you have any questions or comments about this article? If so, feel free post your questions on the Map Suite Discussion Forums or leave feedback at the ThinkGeo Blog.

Additional Resources

About the Author

Val Guillou is a GIS analyst and developer at ThinkGeo, a software company specializing in geospatial software with an emphasis on software development tools and GPS tracking solutions.

How To Use GRID with Map Suite

ThinkGeo — Thu, 13 Nov 2008 05:38:13 GMT

This article will introduce the Map Suite developer community to the GRID format and help demonstrate how useful GRID can be. GRID can come handy in numerous situations where you need to create custom map displays, perform interpolation or do spatial analysis. We hope that by reading this article you will see more clearly how to apply GRID to your own industry and reap the benefits it provides.

Introduction

For the purposes of this article we have used the Map Suite Desktop Edition to show the functionality of GRID, but please note that GRID functionality is also available in the Map Suite Web and Engine editions.

Note: This article is meant to be used as a tutorial for using GRID as a GIS technique, not as a definitive tool for soil analysis. The soil quality examples included here are fictitious, and the soil quality calculations based on pH and Magnesium levels do not come from an authoritative source in agriculture.

GRID Explained

A GRID is a raster format that defines a geographic space as an array of equally sized squares (cells) arranged in rows and columns. Each cell stores a numeric value that represents a geographic attribute (such as elevation, surface slope, soil pH, etc.) for that unit of space. Each grid cell is referenced by its x, y coordinate location.

File Format

The format of the GRID file is ASCII and contains two main parts, the header and the body. The header consists of the first few lines for references of the grid such as the number of columns, the number of rows, the x and y coordinate of the lower left of the grid, the cell size and the no data value (which will be used in the body of the GRID file to represent a null value). The body contains the cell values listed in the order they would naturally appear from left to right and from top to bottom.

Example of ASCII GRID Format:

ncols         4
nrows         6
xllcorner     0.0
yllcorner     0.0
cellsize      50.0
NODATA_value  -9999
-9999 -9999 5 2
-9999 20 100 36
3 8 35 10
32 42 50 6
88 75 27 9
13 5 1 -9999
etc...

Getting Started

Now that we have covered the theory of the GRID, we are going to use a very concrete example to show how useful GRID can be in practical GIS applications.

Let's say that we have a point-based shapefile representing some sample points where the pH (acidity level) of the soil was measured on a field.

Fig 1: Point-based shapefile of sample pH levels.

Fig 2: Map legend.

Now with those few sample points, we want the entire field to be covered with a pH value. This is when GRID comes in handy. Using an interpolation method, IDW (Inverse Distance Weighing), we will create a GRID and then display it on the map to show clearly the different pH values throughout the field.

Creating the GRID

Before creating the GRID, we need to decide the extent of the grid, the size of the cells and the value for no data. In our case, we are going to take a slightly larger extent of the field and we are going to have a cell size of 0.0001 (we are in decimal degrees, so 0.0001 degrees are about 9.6 meters). The no data value is -9999. This means that any cell that is outside the field (where the pH value is irrelevant), we will assign it the -9999 value.

In the Click event of a Button, we will write the logic to create the GRID.

Private Sub btnIDW_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnIDW.Click
        Dim gridExtent As New StraightRectangle(Map1.CurrentExtent)
        Dim cellSize As Double = 0.0001
        Dim NoDataValue As Double = -9999

        AddHandler GridLayer.CalculateCellValue, AddressOf CalculateCellValueHandlerIDW
        Dim Result As Boolean = GridLayer.CreateGridFile("..\PHIDW_2_200_A.grd", gridExtent, cellSize, NoDataValue)

        If Result = True Then
            MessageBox.Show("Grid File saved successfully.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information)
        Else
            MessageBox.Show("Saving Grid File Failed.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information)
        End I
    End Sub

At the creation of the GRID, the event CalculateCellValue is going to be raised for each cell to assign a value. So we are going to write the interpolation algorithm in the handler CalculateCellValueHandlerIDW. In our example, we are using IDW interpolation, or Inverse Distance Weighing. This is a common method for interpolation that assigns values to unknown locations based on some scattered set of known points – which is exactly the case in our example. This interpolation has two variables: The number of points to take into account (based on distance) and the power parameter. Playing with those two variables is going to give a result with smoother or sharper peaks.

Notes: We are using IDW interpolation in this example, but you are free to use any other type of interpolation or algorithm to calculate the cell value. For more information on interpolation, check the following site: http://en.wikipedia.org/wiki/Multivariate_interpolation

Private Sub CalculateCellValueHandlerIDW(ByVal CellExtent As StraightRectangle, ByRef CellValue As Double)
        Dim CellULx As Double = CellExtent.UpperLeftPoint.X
        Dim CellULy As Double = CellExtent.UpperLeftPoint.Y
        Dim CellLRx As Double = CellExtent.LowerRightPoint.X
        Dim CellLRy As Double = CellExtent.LowerRightPoint.Y

        Dim xp As Double = CellExtent.Center.X
        Dim yp As Double = CellExtent.Center.Y
        Dim CellCenterPointShape As New PointShape(xp, yp)
        Dim CenterRecords() As Integer = Map1.Layers(0).QueryByDistance(CellExtent, 15, MapLengthUnits.metres, Map1.MapUnit)

        If CenterRecords.GetLength(0) = 1 Then

            Dim NearestRecords() As Integer = Map1.Layers(1).QueryByDistance(CellCenterPointShape, 200, MapLengthUnits.metres, Map1.MapUnit)
            If NearestRecords.GetLength(0) > 0 Then
                Dim NearestPointShapes() As PointShape = CType(Map1.Layers(1).GetShapes(NearestRecords), PointShape())
                Dim NearestValues(NearestRecords.GetLength(0) - 1) As String
                For i As Integer = 0 To NearestRecords.GetLength(0) - 1
                    NearestValues(i) = Map1.Layers(1).DataQuery(NearestRecords(i), "pH")
                Next i
                'This is the algorithm for IDW interpolation
                Dim Power As Double = 2
                Dim Zi, Zx1, Zx2, Zx, Di As Double
                For i As Integer = 0 To NearestValues.GetLength(0) - 1
                    Zi = CDbl(NearestValues(i))
                    Di = CellCenterPointShape.DistanceTo(NearestPointShapes(i), Map1.MapUnit, MapLengthUnits.metres, DistanceTypes.Shortest)
                    Zx1 = Zx1 + (Math.Pow((1 / Di), Power) * (Zi))
                    Zx2 = Zx2 + ((Math.Pow((1 / Di), Power)))
                Next
                Zx = Zx1 / Zx2
                CellValue = Zx
            Else
                CellValue = -9999
            End If
        Else
            CellValue = -9999
        End If
    End Sub

In our example, we are using a distance of 200 meters to get the sample points within that distance and we are using a power of 2. By specifying a higher power, more emphasis is placed on the nearest points, giving a smoother result. By specifying a lower power, more influence is placed on the points that are farther away, giving a sharper result.

Displaying the GRID

Now that we have the GRID created, we need to display it. This article will demonstrate two different ways of displaying the GRID. For the first way, we will apply a specific color to any cell belonging to a certain class. The second method uses a gradient to go from one color to another. The purpose is to show different ways one GRID can be displayed.

Using ClassBreaks

We are going to display the cells of the GRID in the same way as we did for the original shapefile of sample points. Note that you might want to remove the two shapefiles from the Map so that they do not appear on top of the GRID.

Dim STR_GridFile As String = "..\SoilQuality.grd"
        Dim gridlayer As GridLayer = New GridLayer(STR_GridFile)
        gridlayer.LowerThreshold = 0
        gridlayer.UpperThreshold = Double.MaxValue
        gridlayer.ThresholdUnit = ThresholdUnits.miles
        gridlayer.IsNonValueTransparent = True
        Dim gridranges As RangeCollection = New RangeCollection()
        gridranges.Add(New Range(7.54, 7.9, Color.FromArgb(0, 255, 0)))
        gridranges.Add(New Range(7.21, 7.54, Color.FromArgb(128, 255, 128)))
        gridranges.Add(New Range(7.15, 7.21, Color.FromArgb(224, 251, 132)))
        gridranges.Add(New Range(7.08, 7.15, Color.FromArgb(225, 255, 0)))
        gridranges.Add(New Range(7.0, 7.08, Color.FromArgb(245, 210, 10)))
        gridranges.Add(New Range(6.83, 7.0, Color.FromArgb(255, 128, 0)))
        gridranges.Add(New Range(6.2, 6.83, Color.FromArgb(255, 0, 0)))
        gridlayer.Ranges = gridranges

        Map1.GridLayers.Add(gridlayer)

Fig 3: GRID resulting from sample points interpolation displayed with Class Breaks.

Using Gradient

We are going to display the cells of the GRID with a gradient going progressively from red (for low pH) to green (for high pH). Note that in addition to Map, Layer (the vector shapefile layer) has a GRIDLayers collection so that GRID files can be displayed in the desired order. Here we are displaying the GRID file between the Field Layer and the sample points Layer.

Dim STR_GridFile As String = "..\SoilQuality.grd"
        Dim gridlayer As GridLayer = New GridLayer(STR_GridFile)
        gridlayer.LowerThreshold = 0
        gridlayer.UpperThreshold = Double.MaxValue
        gridlayer.ThresholdUnit = ThresholdUnits.miles
        gridlayer.IsNonValueTransparent = True
        Dim gridranges As RangeCollection = New RangeCollection()

        Dim Alpha As Integer = 255
        gridranges.Add(New GradientRange(6.2, Color.FromArgb(Alpha, Color.FromArgb(255, 0, 0)), 7.9, Color.FromArgb(Alpha, Color.FromArgb(0, 255, 0))))
        gridlayer.Ranges = gridranges
     Map1.Layers(0).GridLayers.Add(gridlayer)

Fig 4: GRID resulting from sample points interpolation displayed with gradient. The Layer with the sample points appears on top.

Multi GRID operations

One of the big advantages of GRID is to be able to create a new GRID by analyzing and performing calculations on the cell values of an existing GRID, or by combining two existing GRIDs to create a third one. For our next example, we have a second GRID that represents Magnesium levels throughout the field from 40 to 95 ppm. We will combine the pH value GRID and the Magnesium level GRID to create a third, composite GRID.

Displaying the GRID for Magnesium

We are going to display the GRID Magnesium_Level using a gradient. (This previously-created GRID is supplied to us for the purpose of this example.)

Dim STR_GridFile As String = "..\Magnesium_Level.grd"
        Dim gridlayer As GridLayer = New GridLayer(STR_GridFile)
        gridlayer.LowerThreshold = 0
        gridlayer.UpperThreshold = Double.MaxValue
        gridlayer.ThresholdUnit = ThresholdUnits.miles
        gridlayer.IsNonValueTransparent = True
        Dim gridranges As RangeCollection = New RangeCollection()
        gridranges.Add(New GradientRange(40, Color.FromArgb(254, 215, 186), 90,    Color.FromArgb(105, 46, 1)))
        gridlayer.Ranges = gridranges
        Map1.Layers(0).GridLayers.Add(gridlayer)

Fig 5: GRID of Magnesium level in PPM from 40 to 95. The darker color the higher the value.

Creating a third GRID from pH GRID and Magnesium GRID

For our example crop, the combination of a pH value between 7.0 and 7.5 and a high magnesium level represents the best soil. The resulting GRID will represent soil quality for that crop by combining the two GRIDs. The cell values will be calculated according to a common formula used by agricultural engineers. We attribute a factor for each pH value and Magnesium level, then we combine the two factors to get the soil quality for that crop.

pH Level	Factor
6.20 to 6.40	5
6.40 to 6.60	6
6.60 to 6.80	7
6.80 to 7.00	8
7.00 to 7.20	9
7.20 to 7.40	10
7.40 to 7.60	9
7.60 to 7.80	8
7.80 to 8.00	7

Table 1: pH factors

Mg Level	Factor
40 to 45	1
45 to 50	2
50 to 55	3
55 to 60	4
60 to 65	5
65 to 70	6
70 to 75	7
75 to 80	8
80 to 85	9
85 to 90	10

Table 2: Mg factors

To determine the soil quality, we will combine the pH factor with the Mg factor. For example, if the pH is 6.67 and the Mg level is 55, the soil quality index will be 28 (7 * 4). The soil quality index goes from a minimum of 5 to a maximum of 100.

Private Sub btnSoilQuality_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnSoilQuality.Click
        Dim gridExtent As New StraightRectangle(Map1.Layers(0).GridLayers(0).Extent)
        Dim cellSize As Double = 0.0001
        Dim NoDataValue As Double = -9999

        AddHandler GridLayer.CalculateCellValue, AddressOf CalculateCellValueSoilQuality

        Dim Result As Boolean = GridLayer.CreateGridFile("..\SoilQuality.grd", gridExtent, cellSize, NoDataValue)

        If Result = True Then
            MessageBox.Show("Grid File saved successfully.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information)
        Else
            MessageBox.Show("Saving Grid File Failed.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information)
        End If
    End Sub

Private Sub CalculateCellValueSoilQuality(ByVal CellExtent As StraightRectangle, ByRef CellValue As Double)
        Dim CellULx As Double = CellExtent.UpperLeftPoint.X
        Dim CellULy As Double = CellExtent.UpperLeftPoint.Y
        Dim CellLRx As Double = CellExtent.LowerRightPoint.X
        Dim CellLRy As Double = CellExtent.LowerRightPoint.Y

        Dim xp As Double = CellExtent.Center.X
        Dim yp As Double = CellExtent.Center.Y
        Dim CellCenterPointShape As New PointShape(xp, yp)

        Dim pHValue As Double = Map1.Layers(0).GridLayers(0).GetCellValue(xp, yp)
        Dim MgValue As Double = Map1.Layers(0).GridLayers(1).GetCellValue(xp, yp)

        If pHValue <> -9999 And MgValue <> -9999 Then
            CellValue = GetSoilQualityIndex(pHValue, MgValue)
        Else
            CellValue = -9999
        End If
    End Sub

Private Function GetSoilQualityIndex(ByVal pHValue As Double, ByVal MgValue As Double) As Double
        Dim pHFactor, MgFactor As Integer
      
        If pHValue < 6.4 Then
            pHFactor = 5
        ElseIf pHValue < 6.6 Then
            pHFactor = 6
        ElseIf pHValue < 6.8 Then
            pHFactor = 7
        ElseIf pHValue < 7.0 Then
            pHFactor = 8
        ElseIf pHValue < 7.2 Then
            pHFactor = 9
        ElseIf pHValue < 7.4 Then
            pHFactor = 10
        ElseIf pHValue < 7.6 Then
            pHFactor = 9
        ElseIf pHValue < 7.8 Then
            pHFactor = 8
        Else
            pHFactor = 7
        End If

        If MgValue < 45 Then
            MgFactor = 1
        ElseIf MgValue < 50 Then
            MgFactor = 2
        ElseIf MgValue < 55 Then
            MgFactor = 3
        ElseIf MgValue < 60 Then
            MgFactor = 4
        ElseIf MgValue < 65 Then
            MgFactor = 5
        ElseIf MgValue < 70 Then
            MgFactor = 6
        ElseIf MgValue < 75 Then
            MgFactor = 7
        ElseIf MgValue < 80 Then
            MgFactor = 8
        ElseIf MgValue < 85 Then
            MgFactor = 9
        Else
            MgFactor = 10
        End If

        Return pHFactor * MgFactor

    End Function

Now that we have created the GRID for Soil Quality, we are ready to display it.

Dim STR_GridFile As String = "..\SoilQuality.grd"
        Dim gridlayer As GridLayer = New GridLayer(STR_GridFile)
        gridlayer.LowerThreshold = 0
        gridlayer.UpperThreshold = Double.MaxValue
        gridlayer.ThresholdUnit = ThresholdUnits.miles
        gridlayer.IsNonValueTransparent = True
        Dim gridranges As RangeCollection = New RangeCollection()
        gridranges.Add(New Range(0, 25, Color.FromArgb(216, 253, 193)))
        gridranges.Add(New Range(25, 40, Color.FromArgb(182, 251, 140)))
        gridranges.Add(New Range(40, 55, Color.FromArgb(137, 248, 71)))
        gridranges.Add(New Range(55, 70, Color.FromArgb(96, 239, 10)))
        gridranges.Add(New Range(70, 85, Color.FromArgb(75, 188, 7)))
        gridranges.Add(New Range(85, 100, Color.FromArgb(52, 131, 5)))
        gridlayer.Ranges = gridranges
        Map1.Layers(0).GridLayers.Add(gridlayer)

Fig 6: GRID for soil quality.

Fig 7: Soil quality map legend.

Conclusion

We hope that the simple examples in this article have shown you more clearly how GRID can help you perform and enhance various tasks in your industry. Keep in mind that the examples shown are very simplistic and that GRID is capable for far more sophisticated uses. In the future, we plan to add more white papers related to GRID to show how this technology can be used for a variety of additional tasks, such as surface analysis, diffusion modeling, zonal functions and more types of interpolations.

Downloads

Download GRID Demo Application
Note: You will need to download the Map Suite Desktop .NET GIS Control Free Evaluation in order to run the example in this article. (Registration Required)

Have Questions?

Do you have any questions or comments about this article? If so, feel free post your questions on the Map Suite Discussion Forums or leave feedback at the ThinkGeo Blog.

Additional Resources

About the Author

Val Guillou is a GIS analyst and developer at ThinkGeo, a software company specializing in geospatial software with an emphasis on software development tools and GPS tracking solutions.

Implementing a Custom Zoom Bar with Map Suite

ThinkGeo — Wed, 12 Nov 2008 08:43:28 GMT

When working with customers, many times I am asked, "How do I implement a custom zoom bar into my application?" At first glance this may seem like a difficult task, but with a little explanation on a few concepts and some sample code, you can easily implement a full-featured zoom bar that meets the needs of your application. In this article I will show you how to build a custom zoom bar using the prebuilt zoom levels defined within Map Suite Web Edition; however, the same concepts apply to building a custom zoom bar using the Map Suite Desktop Edition as well.

Zoom Levels Explained

The Map Suite Desktop, Web and Engine products each come with eighteen prebuilt zoom levels to handle the most common zooming scenarios, ranging from worldwide coverage down to local streets. Having these prebuilt zoom levels at your disposal gives you complete control over how the map is rendered at each zoom level. For example, if you have a map of the world, you wouldn't want to show a lot of detail like country names or roads when the map is zoomed completely out. But as you zoom in, typically you would want to turn on more information such as labels and other map features. With Map Suite you can do just that — from tailoring ZoomLevel18 for views that show the entire globe, down to customizing ZoomLevel01 for a very detailed zoom area like local streets or small land parcels.

Note: Map Suite also allows you to specify your own zoom levels if the prebuilt levels don't meet your needs.

Getting Started

Now that we have covered how zoom levels work, let's get to the fun part: building our sample application with a custom zoom bar. To get started, you will need to create a new ASP.NET web application in Visual Studio 2005. Next, you will need to reference the Map Suite Web Edition .NET Control and drag it on to the web page. Also, don't forget to add the HTTP Handler section to your Web.config file so the map control can render properly.

Now let's add some code to the Page_Load event to initialize the Map and load up our layer representing all the countries in the world. Additionally, we will write some code to color these countries in a reddish hue and turn on country name labeling for zoom levels one to fourteen.

Page_Load Code:

if (!IsPostBack)
	{
		// Set property of map control
		Map1.MapUnit = MapLengthUnits.DecimalDegrees;
		Map1.Mode = Map.ModeType.Pan;
		Rectangle Rect = new Rectangle(0, 0, (int)Map1.Width.Value, (int)Map1.Height.Value);
		Map1.CanvasGeoBrush = new GeoLinearGradientBrush(Rect, GeoColor.GeographicColors.Ocean1, GeoColor.GeographicColors.Ocean2, GeoLinearGradientMode.ForwardDiagonal);
		Map1.AjaxEnabled = true;
		
		// Load world countries layer
		Layer cntryLayer = new Layer(this.Server.MapPath("") + @"\SampleData\world\cntry02.shp", true);
		//Color Countries with labels for all zoom level 14 and below
		cntryLayer.ZoomLevel01.GeoStyle = GeoAreaStyles.GetHueFamilyStyle(6, GeoColor.KnownColors.Red, GeoColor.KnownColors.Gray);
		cntryLayer.ZoomLevel01.GeoTextStyle = GeoTextStyles.Country1("CNTRY_NAME");
		cntryLayer.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.ZoomLevel14;
		//Color Countries with no labels to higest zoom levels
		cntryLayer.ZoomLevel14.GeoStyle = GeoAreaStyles.GetHueFamilyStyle(6, GeoColor.KnownColors.Red, GeoColor.KnownColors.Gray);
		cntryLayer.ZoomLevel14.ApplyUntilZoomLevel = ApplyUntilZoomLevel.ZoomLevel18;
		Map1.Layers.Add(cntryLayer);
		
		// Save some values in session
		Session.Add("FullScale", Map1.CurrentScale);
	}

Once you have this code implemented, you should be able to run your project and have a map displaying similar to the one below.

HTML Code

Now that we have a simple map displaying, it's time to take it to the next step and create our custom zoom bar using standard HTML. To do this, we will create a rather large zoom bar which has a button for each of the eighteen prebuilt zoom levels within Map Suite. If eighteen zoom levels seem like too many, remember that you have complete control over the number of zoom levels and you can implement the number that makes sense for your application. Below is the HTML that you'll need in order to implement a zoom bar with all eighteen levels. As you will notice, for each Zoom Button we make an AJAX call and pass in the level that each button represents. Once you have the HTML implemented, the next step is to add the server side code to zoom the map in to the proper level.

HTML Code:



	[script removed] Local


	[script removed]


	[script removed]


	[script removed]


	[script removed]


	[script removed] City


	[script removed]


	[script removed]


	[script removed]


	[script removed] Area


	[script removed]


	[script removed]


	[script removed]


	[script removed] Country


	[script removed]


	[script removed]


	[script removed]


	[script removed] World

Server Side Code

With the zoom bar now implemented in the webpage, it's time to write some server side code to capture the AJAX event and zoom the map in to the proper level. To handle the AJAX event raised from the JavaScript click event on the zoom bar button, we need to implement the Map's AjaxPostback event, write a case statement based on the argument from each zoom bar button and set the map zoom level accordingly. Below is some sample code showing how to implement this functionality.

Map1_AjaxPostback Code:

protected void Map1_AjaxPostback(object sender, AjaxPostbackEventArgs e)
	{
		switch (e.EventName)
		{
			case "ClickLevel1":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel01);
				break;
			case "ClickLevel2":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel02);
				break;
			case "ClickLevel3":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel03);
				break;
			case "ClickLevel4":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel04);
				break;
			case "ClickLevel5":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel05);
				break;
			case "ClickLevel6":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel06);
				break;
			case "ClickLevel7":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel07);
				break;
			case "ClickLevel8":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel08);
				break;
			case "ClickLevel9":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel09);
				break;
			case "ClickLevel10":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel10);
				break;
			case "ClickLevel11":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel11);
				break;
			case "ClickLevel12":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel12);
				break;
			case "ClickLevel13":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel13);
				break;
			case "ClickLevel14":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel14);
				break;
			case "ClickLevel15":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel15);
				break;
			case "ClickLevel16":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel16);
				break;
			case "ClickLevel17":
				Map1.CurrentScale = GetScaleFromZoomlevel(Map1.Layers[0].ZoomLevel17);
				break;
			case "ClickLevel18":
				Map1.CurrentScale = (Double)Session["FullScale"];
				break;
			case "ZoomIn":
				Map1.ZoomIn(20);
				break;
			case "ZoomOut":
				Map1.ZoomOut(20);
				break;
			case "TrackZoom":
				Map1.Mode = Map.ModeType.TrackZoomIn;
				break;
			case "PreviousExtent":
				Map1.GetPreviousExtent();
				break;
			case "ToggleExtent":
				Map1.ToggleMapExtents();
				break;
			case "FullExtent":
				Map1.CurrentExtent = Map1.Layers[0].Extent;
				break;
			case "PanLeft":
				Map1.Pan(PanDirection.Left, 20);
				break;
			case "PanRight":
				Map1.Pan(PanDirection.Right, 20);
				break;
			case "PanUp":
				Map1.Pan(PanDirection.Up, 20);
				break;
			case "PanDown":
				Map1.Pan(PanDirection.Down, 20);
				break;
			case "PanNorthEast":
				Map1.Pan(45, 20);
				break;
			case "PanNorthWest":
				Map1.Pan(315, 20);
				break;
			case "PanSouthEast":
				Map1.Pan(135, 20);
				break;
			case "PanSouthWest":
				Map1.Pan(225, 20);
				break;
			// Click zoom level button in zoom bar
			default:
				break;
		}
	
		// Sent value back and we will deal with it in client by "CustomCallback" function
		Map1.AjaxReturnArgs = "Level" + GetLevelNumber(Map1.CurrentScale).ToString();
	}

As you can see from the code above, for each click level we are calling a function named GetScaleFromZoomLevel and passing in the associated zoom level. This function returns the new zoom level by calculating the midpoint of the zoom level's scale. Once the new scale is calculated, all that remains is to set this scale to the Map's Current Scale property. The code for the GetScaleFromZoomLevel function that returns the zoom level's midpoint is shown below for your reference.

private double GetScaleFromZoomlevel(PresetZoomLevel presetZoomLevel)
{
	return (presetZoomLevel.UpperExtent + resetZoomLevel.LowerExtent) / 2;
}

Now the only thing left to do is return the zoom level that we are currently at, so that the zoom bar buttons can be updated accordingly. This is accomplished by utilizing the GetLevelNumber function and the Map's AjaxReturnArgs property. In case you're not familiar with the AjaxReturnArgs property, it s a mechanism for passing data back to the client code. At the end of the Map1_AjaxPostback event handler you will see the following line of code, which sets the AjaxReturnArgs property to the Zoom Level we are currently displaying:

Map1.AjaxReturnArgs = "Level" + GetLevelNumber(Map1.CurrentScale).ToString();

In case you were curious what the GetLevelNumber function does, it takes the CurrentScale of the map, compares it against all of the zoom levels and returns the current zoom level. The code for this function is provided below for your reference.

GetLevelNumber Function Code:

public int GetLevelNumber(double scale)
	{
		int result;
		if (scale < 0)
		{
			throw new Exception("The Width of your Map should be more than 0");
		}
		else if (scale < Map1.Layers[0].ZoomLevel01.UpperExtent)
		{
			result = 1;
		}
		else if (scale < Map1.Layers[0].ZoomLevel02.UpperExtent)
		{
			result = 2;
		}
		else if (scale < Map1.Layers[0].ZoomLevel03.UpperExtent)
		{
			result = 3;
		}
		else if (scale < Map1.Layers[0].ZoomLevel04.UpperExtent)
		{
			result = 4;
		}
		else if (scale < Map1.Layers[0].ZoomLevel05.UpperExtent)
		{
			result = 5;
		}
		else if (scale < Map1.Layers[0].ZoomLevel06.UpperExtent)
		{
			result = 6;
		}
		else if (scale < Map1.Layers[0].ZoomLevel07.UpperExtent)
		{
			result = 7;
		}
		else if (scale < Map1.Layers[0].ZoomLevel08.UpperExtent)
		{
			result = 8;
		}
		else if (scale < Map1.Layers[0].ZoomLevel09.UpperExtent)
		{
			result = 9;
		}
		else if (scale < Map1.Layers[0].ZoomLevel10.UpperExtent)
		{
			result = 10;
		}
		else if (scale < Map1.Layers[0].ZoomLevel11.UpperExtent)
		{
			result = 11;
		}
		else if (scale < Map1.Layers[0].ZoomLevel12.UpperExtent)
		{
			result = 12;
		}
		else if (scale < Map1.Layers[0].ZoomLevel13.UpperExtent)
		{
			result = 13;
		}
		else if (scale < Map1.Layers[0].ZoomLevel14.UpperExtent)
		{
			result = 14;
		}
		else if (scale < Map1.Layers[0].ZoomLevel15.UpperExtent)
		{
			result = 15;
		}
		else if (scale < Map1.Layers[0].ZoomLevel16.UpperExtent)
		{
			result = 16;
		}
		else if (scale < Map1.Layers[0].ZoomLevel17.UpperExtent)
		{
			result = 17;
		}
		else
		{
			result = 18;
		}
		return result;
	}

Client Side JavaScript Code

Now that the server side code is completed and the map is zoomed into the proper level, the next step is to update the zoom bar button images to identify which zoom level is currently being displayed on the map. To accomplish this, we will need to implement the CustomCallback JavaScript function on the client side. This will allow us to analyze the return arguments from the server side code and update each zoom bar button image accordingly. For an example on how to implement this, please see the code below:

CustomCallback Javascript Code:


	[script removed]
		function CustomCallback(ajaxReturnArgs)
		{
			if(ajaxReturnArgs != '')
			{
				var ImageButton;
				ImageButton = document.getElementById('Level1');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level2');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level3');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level4');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level5');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level6');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level7');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level8');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level9');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level10');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level11');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level12');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level13');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level14');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level15');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level16');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level17');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById('Level18');
				ImageButton.src='./images/zoombar_off.png';
				
				ImageButton = document.getElementById(ajaxReturnArgs);
				ImageButton.src='./images/zoombar_on.png';
			}
		}
	[script removed]

Once you have this JavaScript function implemented, the appropriate zoom bar button should be highlighted in green, like the "Country" zoom bar button is in the screen shot below.

Summary

In conclusion, you now can see how to build your own custom zoom bar to meet your specific needs. Having this flexibility allows you to control the zoom levels, zoom bar location and overall look of the zoom bar implementation. This can be very important when making the mapping screen easy to use for end users. Below, I have listed several links where you can download the full source code and project to get more familiar with the sample application described in this article. Finally, if you have any questions or suggestions please feel to post comments on the ThinkGeo Blog or Discussion Forums, as these are both great ways for us to hear from the Map Suite community.

Downloads

Download Project and Source Code for Map Suite Zoom Bar Example
Map Suite Web ASP.NET Control (Registration Required)

Note: You will need to download and install the Map Suite Web Edition in order to run the example in this article.

Have Questions?

Do you have any questions or comments about this article? If so, feel free post your questions on the Map Suite Discussion Forums or leave feedback at the ThinkGeo Blog.

Additional Resources

About the Author

Clint Batman is co-founder and President of ThinkGeo, a software company specializing in geospatial software with an emphasis on software development tools and GPS tracking solutions.

Using Map Suite Explorer to Help You Build GIS Apps

ThinkGeo — Wed, 12 Nov 2008 08:32:20 GMT

Map Suite Explorer is a free tool that is included with each Map Suite Desktop, Web, and Engine .NET GIS component. It transforms the Map Suite API into an easy-to-use, user-friendly format that allows for ShapeFile viewing and rendering experimentation without the hassle of writing code. This article will show you how you can use Map Suite Explorer to help you write your GIS applications.

Introduction

Map Suite GIS software has many powerful features, from reprojection and spatial queries to ShapeFile editing and customized labelers. While these features allow a developer the ultimate in control, they can also deter developers with limited Map Suite experience from learning the basics about the Map Suite API.

As a support representative, I see many questions about creating renderers, loading layers, and creating thresholds. To assist with these questions, I sometimes reference Map Suite Explorer as a resource for this information.

What is Map Suite Explorer?

Map Suite Explorer is a free tool that is included with both the evaluation and full versions of each Map Suite Desktop, Web, and Engine .NET GIS component. It is not a .NET mapping control; rather, it transforms the Map Suite API into an easy-to-use, user-friendly format that allows for ShapeFile viewing and rendering experimentation without the hassle of writing code.

Note! You will still need to use the Desktop, Web or Engine controls to render a map your application. Map Suite Explorer itself is an application and uses the Map Suite control to render maps.

How is Map Suite Explorer Going to Help Me?

One example is that rather than writing out the code to load a layer, apply a threshold and a renderer, you can instead use Map Suite Explorer's GUI interface to complete this task in seconds.

To begin, you will need to either download an evaluation edition or purchase a full version of the Map Suite Desktop, Web, or Engine .NET GIS components. (You may need to register on our site to download an evaluation.)

After installing Map Suite, navigate to Start->Programs->ThinkGeo and chose the folder of your product. Next, click on Map Suite Explorer.

Let's start by loading a Layer (ShapeFile) and adding a Threshold and a SymbolRenderer.

First, we load the layer by clicking File->Add New Layer, or clicking the button named "Add New Layer" on the far left of the toolbar.

Here I have selected the STATES.SHP file from the C:\Program Files\ThinkGeo\Map Suite Desktop Edition 2.0\SampleData\USA folder.

Click Open and immediately you will see the STATES layer displayed on the map.

If you need to review several ShapeFiles quickly, you can easily add additional Layers using the same method, or by right-clicking on the Layers node in the tree view.

Right-clicking on the nodes will bring up menus where you can add many different elements to the map. Now that we have a Layer, let's render it in a different color. Map Suite Explorer will automatically assign a color to a Layer unless there is a Threshold set, which is why a SymbolRenderer did not need to be specified right away.

By right-clicking on the Thresholds node, you will have the option to Add a Threshold.

Note this relationship: You add a Threshold to the STATES Layer. In code this would be: Layer.Thresholds.Add(name of threshold)

Now that we have a threshold, our map is blank. This is because we have only defined when we want a Layer to be displayed. We now need to define how we want the Layer displayed.

To do this, right-click on SymbolRenderers for NewThreshold1 and select Add a SymbolRenderer.

We now need to define what symbol we want to be displayed by the SymbolRenderer. Right-click on the Symbols node. For the STATES ShapeFile, we'll choose Add AreaSymbol since our ShapeFile contains area shapes.

Immediately you should see the outline of the states show up.

By changing the Pen and Brush settings, we can control how the layer is rendered.

Okay, Now We Can Change the Colors of the Map, But Other Than the Simple Relationships Demonstrated by the Tree, How Will This Help Me Code?

Map Suite has a feature to create either C#, VB.NET, or XML code that you can use to create your feasibility demos for management, or to see how the code is structured.

By right-clicking on the Map1 node, you get the option to:

Generate VB Code
Generate C# Code
Generate XML

For this example, I chose Generate VB Code and here is the result:

With a couple of minor changes to this code, you can have a working map very quickly.

As you may notice, the code is quite verbose as it sets every single properly of the Map, Layer, Threshold, and SymbolRenderer. While I would not recommend using Map Suite Explorer to write your production code, it can be very helpful in understanding the structure of the Map Suite API.

Summary

Through this introduction to Map Suite Explorer, we have learned to load and render layers as well as create code that can be helpful in building demo applications. Additionally, Map Suite Explorer has shown it can display relationships between objects in the Map Suite .NET GIS components. Although this information is available in the documentation, Map Suite Explorer's visual representation of those relationships may prove to be more intuitive and helpful.

Please see the downloadable code below that demonstrates how you could use Map Suite Explorer-created code to jump start your experience with Map Suite!

Downloads

Map Suite Explorer Sample Code in VB.NET

Have Questions?

Do you have questions or comments about this article? Feel free post your questions on the Map Suite Discussion Forums.

Additional Resources

About the Author

Ryan Desemo is one of ThinkGeo's lead customer support representatives and a technological guru.

Building Scalable Mapping & GIS Apps with Web Services

ThinkGeo — Wed, 05 Nov 2008 10:52:37 GMT

With the emergence of popular online mapping applications over the past few years, more businesses are seeing a need to build mapping and GIS (Geographic Information Systems) functionality into their own custom applications. While online services like Google Maps & Virtual Earth work well in some cases, many times programmers need more control over the map data, map rendering, GIS capabilities, security and overall architecture. In this article, I will show you how to build a scalable mapping application utilizing a web service and how to consume the web service from a client application.

Getting Started

Typically, when I get ready to build a new mapping application, I take a look at how the application will be used and try to break the map data into two separate categories:

Base Map – The base map is made up of the relatively static map data that you always want to show. Typically, these base maps are made up of common features like political boundaries, water features, roads and points of interest. For this example, I'm going to keep the base map very simple and just use an outline of the United States. If I wanted to use a more detailed base map, I would utilize one of the Map Suite Data Plugins to take care of the map data and rendering logic.
Dynamic Map Data – This type of map data changes frequently and will need to be updated regularly. Typically, this type of data is stored in a database that is updated by the application or other outside sources. In this example, I will again keep it simple and simulate plotting the location of two customers in the United States.

Now that you have an idea of the two different types of map data we will be dealing with, we can get started building the web service that will serve up our base maps.

The Web Service

The main goal we need to accomplish with this web service is to provide a high performance, scalable way to render the base maps. These base maps will then be consumed by our sample application. Encapsulating the logic to render the base maps into a web service allows us several advantages. These include centralized map data storage, map data only being loaded into memory once for all users, and finally, you can easily scale web services with a load balancer if demand grows.

To achieve maximum performance, we are going to utilize the Map Suite Engine Edition .NET component. This component will do the heavy lifting of rendering the map image that will be consumed by our sample application. To get started, you will need to create a new ASP.NET web service project in Visual Studio 2005. Once the new project is loaded, the first thing you will need to do is write the web service initialization code. To do this, you will need to add a Global.asax file to your web service. The Global.asax code below is where the MapEngine object is instantiated and the map data is loaded so it can be used for all web service requests.

Global.asax Code:

using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.SessionState;
using MapSuite;

namespace MapWebServiceExample
{
	public class Global : System.Web.HttpApplication
	{
		protected void Application_Start(object sender, EventArgs e)
		{
			//Instantiate the MapEngine component
			MapEngine mapServer = new MapEngine();
			//Create the Layer Object that loads the data for the USA outline
			Layer stateLayer = new Layer(this.Server.MapPath("") + @"\SampleData\STATES.shp");
			//Set the color of the states to use the State1 geostyle
			GeoStyle stateGeoStyle = GeoAreaStyles.GetSimpleAreaStyle
				(GeoColor.GeographicColors.State1, GeoColor.KnownColors.Black);
			stateLayer.ZoomLevel01.GeoStyle = stateGeoStyle;
			//Apply this color & style to all zoom levels
			stateLayer.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.ZoomLevel18;
			//Add the state layer to the map
			mapServer.Layers.Add(stateLayer);
			//Store the map engine object to Application state
			Application.Add("mapServer", mapServer);
		}
		
		protected void Application_End(object sender, EventArgs e)
		{
			//Clear the application
			Application.Clear();
		}
	}
}

Now that we have written the code to initialize the web service, the next step is to create a WebMethod that our client application can call to retrieve the map image. To accomplish this, you will need to add a new web service page to your solution with an .asmx extension. For this example, I called the web service page MapService.asmx and exposed one public WebMethod called GetMapImage. The GetMapImage method takes in a few parameters so we can create the proper map image for the consuming application. These parameters include:

uLX – upper left x coordinate of the map image requested
uLY – upper left y coordinate of the map image requested
lRX – lower right x coordinate of the map image requested
lRY – lower right y coordinate of the map image requested
height – height of image requested
width – width of the image requested
quality – quality of compressed image returned

With these parameters, we can now create the specified map image in our web utilizing the map engine object that we initialized in the Global.asax file. To see how this is accomplished, refer to the code below:

MapService.asmx Code:

using System;
using System.Data;
using System.Web;
using System.Collections;
using System.Web.Services;
using System.Web.Services.Protocols;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using MapSuite;
using MapSuite.Geometry;

namespace MapWebServiceExample
{
	/// 
	/// Summary description for Service1
	/// 
	[WebService(Namespace = "http://tempuri.org/")]
	[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
	[ToolboxItem(false)]
	public class MapService : System.Web.Services.WebService
	{
	[WebMethod]
		public byte[] GetMapImage(double uLX, double uLY, double lRX, double lRY, int height, int width, short quality)
		{
			// Handle threading and retrieve the map engine
			System.Threading.Monitor.Enter(Application["mapServer"]);
			MapEngine map1;
			map1 = Application["mapServer"] as MapEngine;
			//Create the Rectangle for the Map Area we want to return using cooridnates
			RectangleR fullExtent = new RectangleR(new PointR(uLX, uLY), new PointR(lRX, lRY));
			//Create new map bitmap and retrieve graphics object from it.
			Bitmap bmp = new Bitmap(width, height);
			Graphics g = Graphics.FromImage(bmp);
			//Pass the graphic objects into the map engine to draw the image
			map1.GetMap(g, fullExtent, width, height, MapLengthUnits.DecimalDegrees, 0);
			//Dispose of graphic object and handle threading
			g.Dispose();
			System.Threading.Monitor.Exit(Application["mapServer"]);
			
			//Create a new memory stream to hold the image
			MemoryStream MemoryStream = new MemoryStream();
			
			//Get codecs
			ImageCodecInfo[] icf = ImageCodecInfo.GetImageEncoders();
			EncoderParameters encps = new EncoderParameters(1);
			EncoderParameter encp = new EncoderParameter(Encoder.Quality, (long)quality);
			
			//Set quality and save the map to the memory stream
			encps.Param[0] = encp;
			bmp.Save(MemoryStream, icf[1], encps);
			MemoryStream.Close();
			//stream the image back to the client
			return MemoryStream.ToArray();
		}
	}
}

The Client Application

Now that we have the web service built, we move our focus onto the client application that will consume the web service and plot the customer locations. For this example, we are going to build a ASP.NET web application utilizing the Map Suite Web ASP.NET server control; however, the web service can be consumed just as easily in a desktop client application utilizing the Map Suite Desktop .NET control.

To get started, you will need to create a new ASP.NET web application in Visual Studio 2005. Next, you will need to reference the Map Suite Web Edition .NET Control and drag it on to the web page. Also, don't forget to add the HTTP Handler section to your Web.config file so the map control can render properly. Finally, you will need to add a web reference to the web service that was created earlier.

Once you have your application ready to start coding, you will need to put some code into the Page_Load event handler and the Map_BeforeLayerDraw event handler, along with some additional coding to display the customer points and handle zooming in and out. The Page_Load event handler code accomplishes a couple things. First, it sets the MapUnit property, which tells the map control which coordinate system to use. In this example, the coordinate system we will be working with is decimal degrees, also known as longitude & latitude coordinates. Next, we write some code to set the initial zoom level and default the map to pan mode. Finally, the last bit of code in the Page_Load calls the DisplayCustomerPoints function, which handles the task of displaying our dynamic customer points on the map.

You may be asking yourself, where does the web service fit in? By writing some code in the Map_BeforeLayersDraw event handler, we will be able to call the web service and draw our base map of the United States on the map control. To do this, we must first instantiate the web service and call the GetMapImage web method. Once we receive the byte array from the web service that contains the map image, the final task is to draw the map image on the map control using the graphics object passed into the event handler.

To make the application a little bit more user friendly, I have added “zoom in” and “zoom out” buttons to allow the user to zoom in and out. To see this code and all of the code mentioned above, please review the below:

Default.aspx Code:

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.IO;
using System.Drawing;
using MapSuite;
using MapSuite.Geometry;

public partial class _Default : System.Web.UI.Page
{
	protected void Page_Load(object sender, EventArgs e)
	{
		if (!IsPostBack)
		{
			//Set our Map Unit so we can use longitude & latitude coordinates
			Map1.MapUnit = MapSuite.Geometry.MapLengthUnits.DecimalDegrees;
			//Tell the map control that we are going to control the extent
			Map1.AutoFullExtent = false;
			//Default the zoom/extent to show the lower 48 states
			Map1.CurrentExtent = new RectangleR(-125, 55, -66, 18);
			//Set the default mode of the map to panning
			Map1.Mode = MapSuite.WebEdition.Map.ModeType.Pan;
			//Enable Ajax capabilites for the map control
			Map1.AjaxEnabled = true;
			//Call the function so we can plot our customer points
			DisplayCustomerPoints();
		}
	}

	protected void Map1_BeforeLayersDraw(System.Drawing.Graphics G)
	{
		//Insantiate the webservice
		localhost.MapService MapMaker = new localhost.MapService();
		//Call the GetMapImage WebMethod
		byte[] images = MapMaker.GetMapImage(Map1.CurrentExtent.UpperLeftPoint.X,
		 Map1.CurrentExtent.UpperLeftPoint.Y,
		 Map1.CurrentExtent.LowerRightPoint.X,
		 Map1.CurrentExtent.LowerRightPoint.Y,
		 Convert.ToInt32(Map1.Height.Value),
		 Convert.ToInt32(Map1.Width.Value),
		 -1);
		//Create a new Bitmap Object using the image stream
		MemoryStream MemoryStream = new MemoryStream(images);
		Bitmap NewImage = new Bitmap(MemoryStream);
		//Draw the image onto the map control
		G.DrawImageUnscaled(NewImage, 0, 0);
	}

	protected void DisplayCustomerPoints()
	{
		//Create a Dynamic Data Layer to hold our customers
		DynamicLayer customers = new DynamicLayer();

		//Create Customer Point for LA
		PointMapShape custLA = new PointMapShape(new PointShape(-118.24, 34.05));
		//Use a Graphic for the customer symbol
		PointSymbol symLA = new PointSymbol
			(new Bitmap(this.Server.MapPath("") + @"\images\customer.png"));
		custLA.ZoomLevel01.GeoStyle.SymbolRenderers.Add(new SymbolRenderer(symLA));
		//Label the customer icon
		custLA.ZoomLevel01.GeoTextStyle = GeoTextStyles.GetSimpleTextStyle
			(null, "Arial", 9, GeoFontStyle.Bold, GeoColor.KnownColors.Black);
		//Apply to all zoom levels
		custLA.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.ZoomLevel18;
		//Name the Customer
		custLA.Name = "LA Customer";
		//Add the customer to the Dynamic Data Layer
		customers.MapShapes.Add(custLA);
		
		//Create Customer Point for KC
		PointMapShape custKC = new PointMapShape(new PointShape(-94.62, 39.11));
		//Use a Graphic for the customer symbol
		PointSymbol symKC = new PointSymbol
			(new Bitmap(this.Server.MapPath("") + @"\images\customermale.png"));
		custKC.ZoomLevel01.GeoStyle.SymbolRenderers.Add(new SymbolRenderer(symKC));
		//Label the customer icon
		custKC.ZoomLevel01.GeoTextStyle = GeoTextStyles.GetSimpleTextStyle
			(null, "Arial", 9, GeoFontStyle.Bold, GeoColor.KnownColors.Black);
		//Apply to all zoom levels
		custKC.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.ZoomLevel18;
		//Name the Customer
		custKC.Name = "Kansas City Customer";
		//Add the customer to the Dynamic Data Layer
		customers.MapShapes.Add(custKC);
		
		//Add Dynamic Data Layer to Map Control
		Map1.DynamicLayers.Add(customers);
	}

	protected void btnZoomIn_Click(object sender, EventArgs e)
	{
		//Zoom the map in by 20%
		Map1.ZoomIn(20);
	}
	protected void btnZoomOut_Click(object sender, EventArgs e)
	{
		//Zoom the map out by 30%
		Map1.ZoomOut(30);
	}
}

Once you have all of this coding completed, you should be able to run your client application and get a result similar to the screen shot below:

Summary

Leveraging web services can allow you to build extremely scalable mapping and GIS solutions. By utilizing the Map Suite Engine .NET Component in the web service, you can centralize all of your base map generation and large map datasets. In addition, you can still enjoy the developer experience of using the Map Suite ASP.NET & Desktop controls to handle all user interactions and display of dynamic map data, among other things. This article barely scratches the surface of what can be accomplished with mapping & GIS web services in conjunction with a rich user interface. The downloadable code can be used as a good starting point for building your own scalable .NET GIS mapping applications.

Downloads

Map Web Service & Client Example Code in C#
Map Suite Engine .NET Component & Web ASP.NET Control (Registration Required)

Note: You will need to download and install these Map Suite components in order to run the example in this article.

Have Questions?

Do you have questions or comments about this article? Feel free post your questions on the Map Suite Discussion Forums or leave feedback at the ThinkGeo Blog.

Additional Resources

About the Author

Clint Batman is co-founder and President of ThinkGeo, a software company specializing in geospatial software with an emphasis on software development tools and GPS tracking solutions.

Implementing Geocode USA Into a SQL Stored Procedure

ThinkGeo — Wed, 05 Nov 2008 10:40:17 GMT

This article will show you how to implement Geocode USA within a managed stored procedure in SQL Server 2005. The simple procedure involves preparing your files, configuring your database environment, creating an assembly and then building your stored procedure from that assembly.

Download Tutorial Materials
Download Demo Application

Steps

1. Prepare Files

Unzip the GeocodeSample.zip file to C:\GeocodeSample. Please note that the included GeocodeUSA.dll is from the free evaluation edition of Geocode USA; if you are a licensed user of the full version, you will want to use your own copy of GeocodeUSA.dll instead.

2. Configure Database Environment

Open the SQL Server 2005 Surface Area Configuration tool and select the Surface Area Configuration for Features.

Enable the CLR Integration so that you can CREATE ASSEMBLY.

Open SQL Server Management Studio and create a new database. In this example we used: GeocodeSample. (The Database Owner must be a SQL server account, not a domain account.)

Once the database has been created, use the following SQL command to alter the database and set TRUSTWORTHY to ON, so that you can use UNSAFE PERMISSION SET.

ALTER DATABASE GeocodeSample SET TRUSTWORTHY ON

Create a new assembly and choose the SQLGeocodeUSA.dll from the Path to Assembly file browser. Be sure to set the Permission Set as Unsafe. Click OK. Now you will see two assemblies: GeoCodeUSA and SQLGeocodeUSA. Double-check that the Permission Set is set to Unsafe.

Now you can create a stored procedure from the assembly. For example:

CREATE PROCEDURE ReverseGeocode
	-- Set default value, idx files directory
	@GeocodeIdxFolder nvarchar(200)='C:\GeocodeIdx2006fe',
	@Longitude float = 0.0,
	@Latitude float = 0.0
AS
	EXTERNAL NAME
		SQLGeocodeUSA.SQLGeocodeUSAEngine.ReverseGeoCode

Then, you can use this procedure as common stored procedure:

EXECUTE [GeocodeSample].[dbo].[ReverseGeoCode]; @Longitude = -95.2808458305725, @Latitude = 38.9553176794061

Which gives you these results:

3. Instantly Configuring the Database Environment

First, start SQL Server Management Studio. Open the GeocodeSample.sql file, then execute the SQL statement.

4. Client Demonstration

Demonstration code is also provided. The SQLGeocodeUSA project is a class library project, which acts as a bridge between the Geocode USA core and SQL Server 2005. You can use the SQLGeocodeClientDemo to demonstrate how to call the stored procedure in client code.

Building Thematic Maps Using Class Break Renderers and Map Suite

ThinkGeo — Wed, 05 Nov 2008 10:29:15 GMT

In Map Suite, the SymbolClassBreakRenderer class allows for multiple symbols to be defined that correlate to ranges or class breaks. For example, you can use class breaks to produce a map that visually shows different population sizes. You can use this powerful feature to render your maps based on many types of differing values -- this article will show you the way.

Introduction

If you need to build thematic maps (maps that provide information on a specific themes such as spatial distribution of population, timber volumes, weather, vegetation etc.) you can do so quickly and easily using the SymbolClassBreakRenderer Class in Map Suite. This article will show you the basics of getting started on your way to building your own feature rich mapping and spatial applications.

(NOTE: This article references the ClassBreakRendererApp that is available in the sample applications with both the trial and full versions of Map Suite. This article also focuses on the Winforms Edition of Map Suite but most of the concepts and all of the example code applies for the Webforms (ASP.NET) Edition as well.)

Opening the Sample Applications in Visual Studio.NET Solution

Now let's take a look at the SymbolClassBreakRenderer Class and how to use it.

Overview of the SymbolClassBreakRenderer Class

The SymbolClassBreakRenderer Class has the purpose of providing information to Map Suite in helping it determine when and how a portion of the map should be rendered based on a set of ranges or minimum and maximum values. The SymbolClassBreakRenderer is made up of two items: 1) The name of the column in the DBF that will provide the values for our class breaks and 2) a SymbolClassBreakCollection of SymbolClassBreakRenderers.ClassBreaks. For example, in the ClassBreakRendererApp sample application included with Map Suite there are several SymbolClassBreakRenderers.ClassBreaks added to a SymbolClassBreakCollection that define how the percentages of the Hispanic population within each Census tract of Travis County, Texas should be represented in terms of being rendered on the map.

Let's take a look at some sample code so that this is clearer. Our first step is to set up the map by setting the MapUnit property to the proper value, loading a Layer from a Shape File (.shp), setting the ThresholdUnit property on the Layer and creating a new Threshold that we can add our SymbolClassBreakRenderer to:

'-- Set length units for shape files
Map1.MapUnit = MapSuite.Geometry.MapLengthUnits.DecimalDegrees

Dim Layer As New Layer("C:\Program Files\ThinkGeo\YOUR MAPSUITE VERSION\sampledata\usa\austin\austintracts.shp")

'-- Set layer's length units to miles because that is what we want to work with
Layer.ThresholdUnit = ThresholdUnits.miles

'-- Only show this layer when map is zoomed in showing less than 10,000
'-- miles across
Dim Threshold As New Threshold(10000, 0)

For a more detailed explanation of the above code, shape data and DBF files, see the Map Suite Quick Start User's Guide.

Now that we have our Map, Layer and Threshold defined we can start building our SymbolClassBreakRenderer.ClassBreaks that will define how we want the map to display the percentages. To do this we will be defining a SymbolClassBreakCollection as mentioned earlier and adding SymbolClassBreakRenderer.ClassBreaks to it. In the example we want to use the below defined ranges:

Percentage (%)	Display As
Less than 15	Light Goldenrod Yellow
15 - 30	Light Green
30 - 45	Lime Green
45 - 59	Green
More than 60	Dark Green

Now that we know what we need to define for our class breaks, let's look at the code for accomplishing this. Note that we also introduce a new Class called the SymbolClassBreakRenderer.ClassBreakCap. It is explained further in the comments of the code and below:

'-- Define our SymbolClassBreakCollection to hold our class breaks
Dim ClassBreaks As New SymbolClassBreakCollection

'-- First break is 'below 15%'
ClassBreaks.Add(New SymbolClassBreakRenderer.ClassBreak(15, New AreaSymbol(New Pen(Color.Black), New SolidBrush(Color.LightGoldenrodYellow))))

'-- Next break is 'below 30%'
ClassBreaks.Add(New SymbolClassBreakRenderer.ClassBreak(30, New AreaSymbol(New Pen(Color.Black), New SolidBrush(Color.LightGreen))))

'-- Next break is 'below 45%'
ClassBreaks.Add(New SymbolClassBreakRenderer.ClassBreak(45, New AreaSymbol(New Pen(Color.Black), New SolidBrush(Color.LimeGreen))))

'-- Every class break needs a cap. With a cap of 60, here, we are saying
'-- that everything below the cap, or 'below 60%' (which means 45% or
'-- above but below 60%)should be displayed one way and those over the cap
'-- ('60% or above') should be displayed another way.
Dim ClassBreakCap As New SymbolClassBreakRenderer.ClassBreakCap(60, New AreaSymbol(New Pen(Color.Black), New SolidBrush(Color.DarkGreen)), New AreaSymbol(New Pen(Color.Black), New SolidBrush(Color.Green)))

'-- Add the ClassBreakCap to the SymbolClassBreakCollection
ClassBreaks.Add(ClassBreakCap)

Note that each constructor for a SymbolClassBreakRenderer.ClassBreak takes an argument of type Double as a maximum value (all values that fall below the value should be rendered) and a SymbolRenderer. The SymbolClassBreakRenderer.ClassBreakCap Class takes break value that puts a sort of end or "topper" on the class breaks by defining how to render values that fall in the range below the value and the last defined SymbolClassBreakRenderer.ClassBreak as well as the value and anything above. In the last line of code we add the SymbolClassBreakRenderer.ClassBreakCap to the SymbolClassBreakCollection.

Note, for more information on the SymbolRenderer Class, see the Map Suite QuickStart Guides.

Using the SymbolClassBreakRenderer Class

Now we can finally use the SymbolClassBreakRenderer Class by defining what column we will use from the DBF (.dbf) file that is associate with our Shape Date File (.shp). In this case, the column we want to use is 'perchisp01'. This will give us our percentages. If we provide that along with the SymbolClassBreakCollection of our class breaks, Map Suite will automatically render each area appropriately. Below is the code for doing this:

'-- Add layer and class break render to map so it can be displayed
Dim ClassBreakRenderer As New SymbolClassBreakRenderer("perchisp01", ClassBreaks)

Threshold.SymbolRenderers.Add(ClassBreakRenderer)

Layer.Thresholds.Add(Threshold)

Map1.Layers.Add(Layer)

'-- Force map to redraw completely
Map1.Refresh()

In the above code we simply create the new SymbolClassBreakRenderer as described earlier, add it to the SymbolRenderer Collection of the Threshold, add the Threshold to the Layer, and the Layer to the Map. Our last step is to call the Refresh() method of the map so that it can redraw it completely. When we run this code in the ClassBreakRenderersApp sample application, it renders like this:

As you can see, it is very easy to use SymbolClassBreakRenderers in your Map Suite application. With only a few lines of code, and some representative data, you can have professional looking thematic analysis maps to your users in very little time. Remember to check out the ClassBreakRenderersApp sample application to see this code and other features such as traversing the map with operations like Zooming, Panning, Track Zoom etc. as well as SymbolDisplayer class used for creating legends like the one shown on left side of the image above.

Other Resources

Sample Applications

View the Map Suite sample applications online

Discussion Forums

Visit the Discussion Forums online

The Technologies Behind GIS Development

ThinkGeo — Wed, 05 Nov 2008 08:41:08 GMT

If you are new to geographic information systems (GIS) and neocartography, this article is a good primer. Providing a background on GIS and geographical information science, the article takes a view to software development with GIS and the disciplines and technologies used therein. The application of Microsoft's .NET Framework, spatial data formats, geomatics and other tech is covered in detail.

Background on GIS

GIS is an abbreviation for "geographical information system." GIS is an advanced computer technology or computer system that utilizes an analytic framework–a geographic information system–to solve problems, integrate and manage data, as well as understand past, present, or future situations. A GIS is capable of storing, integrating, managing, analyzing, and displaying information that is geographically referenced. The geographical information system enables users to create and manage spatial data and the attributes associated with that data. In a very broad sense, GIS is a map tool that allows users to create searches and analyze and edit spatial data. Further, GIS has many useful applications in the areas of academics, business, and government.

Geographical Information Science is the science behind GIS, which lays the foundation of principles and theories upon which a geographical information system is built. Geographic information systems can be used in many areas, such as the following: resource management (managing offices, stores, targets, and tracking carriers), asset tracking (vehicle tracking and fleet tracking), development (developing map controls, geocoders, reverse geocoders, and .NET Components), route planning (determining evacuation routes and emergency response times in the case of toxic spills or natural disasters), and cartography (the science of map making).

GIS and Geography

Geographical information systems all utilize the science and discipline of Geography. Moreover, GIS uses geographical data to link information or attributes to location data. For example, a geographic information system might link people (attributes) to addresses (location data) or buildings (attributes) to parcels or streets (location data). A geographical information system will take this information and create layers to show the relationships between the attributes and data and combine these layers to provide insight into a user's questions. Geographical data in GIS can be viewed three main ways: Database View, Map View, and the Model View.

GIS Views

The Database View of geographical data is based on a GIS's database, which is a geographic database of the world. This geographic database, also called a geo-database, is a very structured database that describes and defines the world in geographic terms. In a Database type view, users define how certain geographic objects will be represented and viewed. Objects that have a similar representation are stored in the geographical database as classes. Further, each dataset in the geographic database will represent a specific geographic representation of the world. These datasets include the following types: raster datasets (digital elevation models and imagery), networks, terrains, datasets of vector-based features (sets of points, polygons, and lines), cartographic datasets (maps), and address datasets.

The second type of GIS view is the Map View. This type of view involves viewing information on sets of maps to see geographical features and the relationships between these features. Another feature of the map view is that geographic information can be used as windows into a geographical information system's database in a process called geovisualization. This process allows information in the database to be searched, analyzed, and edited. The geovisualization process involves working with a GIS's maps, often referred to as "intelligent maps," and other GIS views, such as summary charts and tables, schematic views of network relationships, and time-based views. In addition to being used as windows into a geographical system's database, maps are the main interface through which a user interacts with a GIS and utilizes its applications. Further, the maps are capable of performing a number of valuable functions, such as data analysis, data queries, data compilations, and cartography.

The third and last view of a GIS is the Model View. The Model View utilizes a process called geoprocessing, which takes information from existing datasets and applies analytic functions to these existing datasets in order to derive new datasets. This geoprocessing results in the creation of a model, which was created for the purpose of answering a question posed by the user. Geoprocessing is utilized in almost all phases of GIS, including data compilation, data management, advanced cartography modeling, and analysis. The database, map, and model views are important parts of all geographical information systems and used at all levels of application in GIS.

GIS Information Sets

Geographical information systems analyze and display geographic information in a series of information sets. These information sets include geographic datasets, maps, workflow models, metadata documents, and data models.

Geographical datasets are databases of geographical information that include networks, topologies, terrains, attributes, and surveys. Maps provide interactive views of geographical data and support advanced GIS applications when interacting with geographical data. Workflow models are collections of geoprocessing procedures that enable users to automate tasks and analyze information. Metadata documents are documents that describe other elements and allow users to access shared geographic knowledge. Finally, data models define the behavior, schema, and integrity rules of geographic datasets and play a vital role in geographic information systems.

GIS Development

GIS development utilizes a geographical information system, GIS technology, the Microsoft .NET framework, and the Global Positioning System (GPS) to build software applications, such as .NET map controls; .NET components; vehicle, fleet, and asset tracking applications; and geocoding and reverse geocoding applications. Many different technologies and file formats are used in GIS development. Some of these technologies and common file formats are as follows: Geomatics, Spatial Analysis, Geospatial Analysis, Cartography, NET Framework, .NET languages (C# and VB.NET), Map SDK (Software Development Kit), GIS SDK (Software Development Kit), Shapefiles, JPEG 2000 format, ECW format, GeoTIFF format, and MrSID format. Software engineers use some or all of the above tools and file formats to develop their GIS applications that can be deployed over the web, on a desktop PC, or even on a mobile or portable device such as a PDA or Pocket PC.

Overview of the Disciplines and Technologies behind GIS Development

This section of the article will discuss the disciplines, tools, techniques, and file formats that are commonly used by software engineers in GIS development. The common technologies and tools that a GIS developer uses come from a wide range of disciplines, such as Geomatics, Spatial and Geospatial Analysis, Geography, Geographical Information Science, Cartography, Computer Science, and Software Development. Each of these disciplines and their technologies will be discussed in greater detail in the next few sections.

Geomatics

Geomatics is the science that studies the mathematics of the earth and focuses on measuring, managing, and analyzing Earth-based data that is spatially referenced. Spatially referenced data is data that is identified according to its location. In addition to this, Geomatics also involves the practice of modeling spatial geometry, making observations about spatial positions, and estimating spatial positions. Geomatics has applications across many disciplines and professions and uses data acquired from many sources, such as air and sea-borne sensors, satellites, and ground instruments. Some of the disciplines which rely on Geomatics are Computer Science, Remote Sensing and Photogrammetry, Cartography, Surveying, Geographic Information Systems, geodesy, navigation, and the Global Positioning System (GPS).

Another view of Geomatics is that it is a branch of the Geographic Information System and specializes in the areas of measuring and surveying Earth-based data. In a broader sense, the science of Geomatics specialized in the tools and techniques that enable and support remote sensing, land surveying, Cartography, and Geographic Information Systems. Finally, in the United States, the application of Geomatics is often called Geospatial Technology.

Spatial Analysis

Spatial Analysis is the term for the process of analyzing spatial model results and geographical data. In order to understand geographical information, spatial analysis is often required. Spatial Analysis enables Geospatial Engineers to estimate, evaluate, predict, and interpret geographical information and data. One of the main methods of spatial analysis is raster analysis. Raster analysis involves the analysis of raster cells, which are grid cells in a matrix. A raster is a data structure that is composed of rows and columns that are used to store images. In a raster data type, data consists of rows and columns of cells in which a single value is stored in each cell. Many satellites transmit raster images of the earth's surface.

The other types of spatial analysis methods are topological overlay and contiguity analysis, surface analysis, and linear analysis. Spatial analysis plays an important role in population analysis and natural disaster analysis. Interestingly, the history of spatial analysis can be traced back to 1854 when John Snow used it to find the source of a cholera outbreak in London.

Geography

The discipline of Geography is closely tied to Geographic Information Systems and has a history that dates back some 4,300 years ago to ancient Mesopotamia where the first city maps were created. Geography studies the location and spatial variation of both natural and human phenomenon on Earth. The study of geography contributes to, as well as draws from, many other disciplines, such as geology, climatology, oceanography, geodesy, cartography, and GIS. The study of geography can roughly be divided into the areas of human geography and physical geography, both of which contain many subfields of study.

With the emergence of geographic information systems and advanced computer technology, geography is becoming increasingly more quantitative, and geographers can now use this technology to better investigate their theories of spatial phenomenon. Modern geography now combines cartography (map making) with geographic information systems to better understand spatial relationships.

Geographic Information Systems

Geographical Information Systems (GIS) is a computer system that creates and manages spatial data and the attributes associated with the spatial data. The roots of GIS run very deep with a history that can be traced back to almost 35,000 years ago when prehistoric people left cave paintings that depicted hunting scenes complete with track lines and tallies that showed the migration patterns of the animals they hunted. These early paintings follow the two-element structure that is the trademark of all modern geographic information systems, which is a graphic file linked to an attribute database.

A good GIS is capable of relating information from many different sources. Further, a good GIS can analyze sources of information that are in different forms. In order for this to work, a geographic information system must know the locations of the variables in the source data by marking the variables with x, y, z designations, which represent longitude, latitude, and elevation, respectively. Any variable that can be located spatially can be entered into a GIS and many types of data in map form can be entered into a GIS. In addition to spatial and map data, satellite images that are developed through remote sensing can also be analyzed to produce map-like layers of digital information.

Data representation is an important aspect of a geographic information system. In a geographic information system, data represents objects in the real world. Data for real world objects can be divided into two abstractions–discrete objects, a building for example–and continuous fields, the elevation of an object for example. In addition, there are two main methods for storing these abstractions–raster and vector.

Raster data stores data in cells that are organized in a series of rows and columns. Each of these cells holds a single value. Most raster data consists of images, however, there is also a value stored for each cell which can be discrete, continuous, or null. A null value is stored if there is no data available.

Vector data uses lines, geometries, and polygons to represent objects. An example of this would be polygons used to represent an in area, out area, or spatial fence in vehicle tracking applications. Vector data models can also apply topography rules when representing objects, such as not allowing polygons to overlap when displaying spatial fences.

Geographic Information System users spend much of their time feeding data into the GIS. This activity is known as data capture, and the data that is captured is stored in a digital format. There are several methods used in data capturing. One method evolves taking existing data that is printed on paper maps and scanning it to produce digital data. This method of data capture produces raster data that can be processed to produce vector data. The next method involves entering survey data from a survey instrument or global positioning system directly into a GIS. Another method of data capture uses satellite remote sensing to collect raster data that can be processed to identify objects.

Geocoding and reverse geocoding are other common techniques used in geographic information systems. Geocoding calculates spatial locations from street addresses and requires a reference theme to Geocode individual addresses. A reference theme can be a road centerline file that contains address ranges. Geocoding uses this reference theme to estimate individual addresses by examining the address ranges that are derived from a database. A geographic information system will then place a dot to approximate the location of the address on the road centerline.

Reverse geocoding returns an estimated street address number for a given coordinate. This process requires a user to take a set of coordinates or click a road centerline theme, and the geographic information system will return an estimated street address for the coordinates. A GIS does this by estimating the street address from a predetermined range that is assigned to the road segment where the coordinates are located.

A GIS is also commonly used in cartography to display graphics that help make relationships between map elements more visible. GIS cartographic work enables users to graphically see the results of analysis in order to better understand them. Also, other information stored in the GIS database, such as a list of addresses, can also be used in analysis.

Cartography

Cartography is the study and practice of map making. Traditionally, maps were created by hand using pens and paper, but today computers have revolutionized cartography. Now maps are created using mapping software, usually CAD or GIS software. Cartography is important in GIS development because maps serve as the visual representation of spatial data. Cartography utilizes special map symbols to represent geographic phenomenon and to visualize the world in an abstract form.

There are two main map types in cartography: general and thematic. General maps are those that are designed for general users. General maps contain a wide variety of features and are usually produced in a series. A topographic map, a map showing a surface and its elevation points, is an example of a general map. Thematic maps, on the other hand, are targeted towards specific users and focus on specific geographic themes. For example, a thematic map might be designed to show social data or represent the distribution of languages throughout a continent.

Computer Science

Computer science is the study of information and computations and their applications in computer systems. One important area of computer science that is used in GIS development is computer programming. Computer programming uses computer programming languages to create a program to solve a computational problem. Software engineering is an aspect of computer science with a focus on designing and developing software applications to achieve practical goals.

Software engineering involves the use of computer programming and high-level programming languages that are object oriented, such as C# and VB.NET. The previous two examples, C# and VB.NET are referred to as .NET languages and are supported by the Microsoft .NET Framework, which is discussed in detail in the next section. Computer programs written in these .NET languages were developed to be executed by the Common Language Runtime or CLR. This CLR is a multiple language execution environment that is part of the .NET Framework.

Object-oriented languages are commonly used to write the code for software applications in GIS development and are used in conjunction with various Software Development Kits, or SDKs. The two most common SDKs used in GIS development are Map SDK and GIS SDK. An SDK is essentially a GIS toolkit or a Map toolkit that includes many tools, sample code, libs, and documentation to help software developers write and develop to Microsoft technologies and products when creating their GIS applications.

.NET Framework

Microsoft's .NET Framework is a platform created by Microsoft that supports software development. The benefit of .NET is that it allows cross-language development, meaning that applications can be developed using a variety of languages. In addition to this, .NET provides a large standard library of structures types and data types.

The .NET Framework was created for several key reasons. The first reason is that the .NET Framework provides interoperability between old code and new code. This enables new libraries to use code from old libraries. The Common Runtime Language (CLR) is another important key feature of .Net. Programming languages on .NET compile into an intermediate language or IL. This IL allows all .NET languages to be run on any computer that supports Common Language Runtime. Another key feature of the .NET Framework is the Common Type System or CTS, which defines a library of data types and programming constructs that are supported by CLR. The CTS defines how these data types and constructs may or may not interact with each other. This feature of .NET allows development in multiple programming languages. Another important key feature of .NET is the Base Class Library (BCL). The BCL provides a library of class types to all languages that use the .NET Framework.

Finally, there is a scaled-down version of the .Net Framework that can be used on small portable devices, such as Pocket PCs and PDAs. This is called the .NET Compact Framework. In addition to the .NET Framework, GIS developers use the Microsoft Visual Studio .NET integrated development environment to write and compile their programs.

GIS File Formats

GIS development utilizes many different file formats, such as Shapefiles, JPEG 2000, ECW, GeoTIFF, and MrSID. A GIS file format is the standard by which geographical information is encoded into a file, and these file formats are created by both government agencies and GIS software developers.

Shapefiles are data types that are commonly used in GIS software products. A Shapefile stores geometric locations and its associated attributes in a vector storage format. Although a Shapefile can store geometric locations, it is not capable of storing topological information. Shapefiles are both a powerful and useful file format because they store the geometrical data types of lines, points, and polygons, as well as the attributes that these data types or shapes represent. Shapes and their corresponding attributes can represent an infinite variety of geographical data.

JPEG 2000 is an image compression file format that can operate at higher compression ratios than a JPEG file without producing blurry artifacts. In addition to this feature, the JPEG 2000 format allows for more progressive and sophisticated downloads.

ECW (enhanced –compression wavelet) file format is a wavelet compression image file format that is optimal for satellite and aerial imagery. Also, ECW is an efficient format for compressing very large images.

GeoTIFF is a format that allows geo-referenced information to be embedded within a TIFF file. Additional information, such as coordinate systems, ellipsoids, and projections are also included to help establish the exact spatial reference for the file.

MrSid is an acronym that stands for Multi-resolution Seamless Image Database and is a file format developed specifically for GIS. MrSID allows massive amounts of image data to be displayed as satellite imagery in map software. MrSid files are easy to steam over the internet because of their quality levels. A software package, GeoExpress, allows GIS developers to read and write MrSID files. Finally, the technology behind MrSID uses lossless wavelet compression to create images.

The Future of GIS Development

In the future, geographical information systems will be used more widely in government, business, science, and industry. With the emergence of Google Maps, vehicle and fleet tracking, asset tracking, satellite tracking, and the need to plot and study geographical data in order to better understand natural disasters and phenomenon, GIS development will likely continue to expand by adding new disciplines, tools, and technologies. GIS technologies are being used throughout the world to help people find places, navigate trips, and plan events. As the planet becomes increasingly interconnected, GIS development will play a major role in this event and, as a result, grow in importance.

Map Data Sources

ThinkGeo — Wed, 05 Nov 2008 08:17:40 GMT

When you're developing your GIS software application, you're going to need spatial data to bring it all together. But where can you obtain that data? This article looks at sources of data and provides examples of sources used in ThinkGeo's own Map Suite and Cygnus Track products. It discusses vector data and its structure, and names sources of free data and premium data alike, both online and offline.

Introduction

ThinkGeo's Map Suite product line and GPS tracking solution—Cygnus Track—both use map data sources for their mapping and tracking applications. The Map Suite products, such as Geocode USA, utilize TIGER® data from the U.S. Census Bureau to develop highly optimized datasets that enable users to find addresses anywhere within the United States. The map datasets for Cygnus Track can be fully customized to use a wide variety of map data sources. This custom map data integration feature allows Cygnus Track users to integrate high resolution satellite and street maps into the system to reflect any part of the world. Many of the types of map data used in ThinkGeo's mapping and asset tracking products, as well as the providers of these map data sources, will be discussed in this article.

In order to develop a better understanding of the applications of map data sources and datasets, it is perhaps a good idea to begin with a general overview of the ThinkGeo products that utilize various map datasets. This next section will provide a brief discussion of the .NET components in the Map Suite product line as well as an overview of Cygnus Track, ThinkGeo's resource and asset tracking solution.

Map Suite Products

The Map Suite 2.0 product line of .NET Development Components consists of Map Suite Desktop, Map Suite Web, Map Suite Engine, Map Suite Pocket PC, and Map Suite Geocode USA. The Map Suite 2.0 product line provides a set of mapping controls and tools that enable C# and VB.NET software developers to build their own geospatial applications for both desktop and web applications. Further, Map Suite 2.0 fully supports Microsoft Visual Studio 2005 and the .NET Framework 2.0.

Map Suite Desktop is a .NET mapping component that allows software developers to build detailed desktop mapping applications. Utilizing Microsoft's .NET Framework v1.1, the APIs for Map Suite Desktop Edition 2.0 incorporate the very latest technology to produce a versatile and user-friendly mapping component. In addition, Map Suite Desktop provides intuitive, streamlined interfaces to help make desktop spatial applications fast and easy. Cutting through the cryptic APIs, which are normally associated with building spatial applications, Map Suite Desktop offers the non-GIS developer the right tools to build spatial applications.

Map Suite Web Edition is an ASP.Net server control that enables C# and VB.NET software developers to build detailed internet mapping applications. Utilizing Microsoft's .NET Framework, the APIs for Map Suite Web Edition allow a developer to easily develop mapping applications on the Web in any of the .NET languages.

Map Suite Engine is a feature-rich low level .NET component that C# and VB.NET software developers can use to generate map images for presentations. Map Suite Engine features a non-visual component library that is specifically designed to generate maps. With this tool, developers can roll their own mapping control in Winforms or integrate a mapping solution with a legacy ASP web on the internet.

Map Suite Pocket PC is a .NET mapping component that enables C# and VB.NET software developers to generate mapping presentations on portable devices using the .NET Compact Framework 2.0. Map Suite Pocket PC features a sophisticated and easy-to-use component library that simplifies map building. By utilizing Map Suite Pocket PC, developers can build full-featured spatial and mapping solutions for Window CE devices and other portable devices.

Map Suite Geocode USA is a .NET geocoding engine that includes a highly optimized dataset encompassing the entire United States. Map Suite Geocode USA features a fast and easy-to-use .NET interface that enables C# and VB.NET software developers to take a United States address and quickly find its geographical location. In addition to geocoding, Map Suite Geocode USA also features reverse geocoding functionality which allows a developer to take a longitude and latitude point and find the closest address to that location. By writing just a few lines of code, a developer can integrate geocoding and reverse geocoding into a single software application. Finally, Geocode USA utilizes the most up-to-date TIGER® dataset from the U.S. Census Bureau to enhance its geocoding capabilities. This enables developers to geocode addresses anywhere within the United States.

Cygnus Track

Cygnus Track is a web-based GPS tracking application that enables owners to manage and track their vehicles and assets. Cygnus Track combines GPS technology, vehicle and asset tracking, and satellite communications networking to produce a GIS product that can be used to track vehicles, fleets, and other mobile assets through tracking devices. These tracking devices, such as cell phones or pagers, can be carried by drivers or mounted into the vehicles. Cygnus Track is based on an ASP.NET model and built on the Microsoft .NET platform, which allows the application to be accessed on any Internet browser, such as Microsoft Internet Explorer.

Cygnus Track is hardware independent, allowing owners to use current GPS tracking devices or the tracking devices of their choice. Cygnus Track can be integrated with any GPS tracking device and can be customized to integrate any geographical dataset, which gives owners maximum flexibility in their asset and resource tracking. Cygnus Track includes two types of map data for its maps: United States and World.

Map Data

Map data is simply the data that is required to represent a map, and data, in the general meaning of the term, is a collection of facts, information, and instructions organized in a format that enables it to be both communicated to and processed by a computer. This type of data format is referred to as digital data because it is data represented in a computer compatible format, which is a format that can be read by a computer. For map data and GIS (Geographical Information System) development, the following file formats are commonly used: Shapefiles, JPEG 2000, ECW, GeoTIFF, and MrSID. Finally, map data is often grouped in a dataset, which is a set of data that has a common theme or similar attributes.

Both Map Suite and Cygnus Track use map data from various map data sources in their applications. The Map Suite .NET Components utilize TIGER®/Line data from the U.S. Census Bureau to expand and enhance the capability and functionality of their map controls. For example, the Map Suite products can be integrated with mapping datasets such as TIGER® street data to enrich the GIS development process and expand the maps with more detailed features like road, railway, and county landmark features. In addition, Map Suite .NET components require a Shapefile (.shp) format for the map datasets used in their mapping and geospatial applications. Shapefiles are the most widely used file format in the GIS community and all of the Map Suite components currently support the Shapefile format.

Cygnus Track's design allows external high-resolution street and satellite maps to be integrated with its United States and World map datasets. The map data sources most commonly used in Cygnus Track data integration are Vector data, which must be in an ESRI shapefile file format, and Raster Imagery Data, which must be used in the following file formats: GeoTIFF, MRSID, ECW, and JPEG 2000.

In the following sections, TIGER® data and the main source for this data, the U.S. Census Bureau, will be discussed in detail as well as Vector Map data. Following these sections, the two major sources for premium map data—Tele Atlas and Navteq—will be discussed. Finally, at the end of this article, the two primary internet resources for map data—geodata.gov and data.geocomm.com—will be briefly discussed.

U.S. Census Bureau and TIGER® Data

With a history that stretches back to the early years of American independence, the United States Census Bureau is the leading source for reliable data about the nation's economy and people. The U.S. Census Bureau has the strategic goal of meeting the needs of businesses, policymakers, nonprofit organizations, and the public by providing current measures of the U.S. economy, population, and governments. Further, the activities of the U.S. Census Bureau include conducting large-scale surveys, updating geographic infrastructures, and collecting, processing, and disseminating data. To support its mapping and geospatial needs for Decennial Census, the U.S. Census Bureau developed the TIGER® system and digital database.

TIGER® is an acronym that stands for "Topologically Integrated Geographic Encoding and Referencing." The TIGER® format is used by the U.S. Census Bureau to describe land attributes such as roads, lakes, rivers, railways, landmarks, hydrology, and buildings. The topological structure of the TIGER® database defines the relationship of these land attributes to each other as well as the location of the attributes. The TIGER® database design is based on the theories of topology, graph theory, and related areas of mathematics in order to produce an accurate mathematical description of the geography of the United States.

The goal of the TIGER® database is to provide automated access to, as well as retrieval of, relevant geographic information about the United States. The U.S. Census Bureau uses the TIGER® System to automate the mapping and geographical activities used in its sample surveys and decennial census programs. In addition to this, the TIGER® System supports the creation and maintenance of a digital geographic database that covers the United States, Puerto Rico, the U.S. Virgin Islands, Midway Islands, American Samoa, the Commonwealth of the Northern Mariana Islands, and Guam. The U.S. Census Bureau also uses the TIGER® system to produce maps for its enumeration and publication programs and to assign individual addresses to geographic entities and census blocks.

TIGER® data files, also called TIGER®/Line files, are digital data that describes geographic features such as roads, rivers, lakes, railways, legal boundaries, buildings, etc. The TIGER® data files also contain information on the latitude and longitude of the geographic features, the names of the features, the types of features, the geographic relationship of one feature to the next, and the address ranges of most streets. In order to use Tiger® data in GIS development applications, a user needs to first import the TIGER® data by using either GIS or mapping software, such as a GIS toolkit, GIS SDK (Software Development Kit), or a map toolkit or map SDK. Finally, TIGER® data files are created by the U.S. Census Bureau's TIGER® database and are considered a public product. The most recent version of TIGER®/Line data is the 2004 Second Edition TIGER®/Line Files.

Vector Map Data

A vector is one method of data type that can be used to store spatial information. Vector data is an abstraction of the real world where positional data is represented in the form of coordinates, and the basic units of spatial information are points, lines, and polygons. Points represent X, Y, Z locations on the earth; lines represent anything that has a length; and polygons represent anything that has a boundary. Moreover, vector data is made up of lines or arcs, and the beginning and end points of these lines or arcs meet at nodes. Vector data stores geographical features that are defined by their boundaries and explicit topology. Finally, vector data models are the most commonly used spatial data models in GIS development. A vector data model represents a geographical feature as a row in a table, and each geographical feature is defined by an X, Y, Z location on the earth's surface.

Produced by the National Geospatial-Intelligence Agency (NGA), Vector Map, Vector Smart Map, or VMAP is a collection of databases providing vector-based GIS data that covers the earth at various levels or scales of detail. These levels of detail are levels of resolutions for viewing the earth and its geographical features. These levels are as follows: Level 0 (Low Resolution), Level 1 (Medium Resolution), and Level 2 (High Resolution).

Level 0 resolution (VMAP 0) is global coverage and in the public domain. This level also provides a worldwide coverage of geospatial data on a small scale of 1:1,000,000 and is available on CD-ROM or as a direct download from the National Geospatial-Intelligence Agency (NGA). Level 0 is an improved and updated version of NGA's Digital Chart of the World (DCW). The entire coverage for Vector Map Level 0 resolution is divided into four major datasets: North America (NOAMER); Europe and North Asia (EURNASIA); South America, Africa, and Antarctica (SOAMAFR); and South Asia and Australia (SASAUS). The data structure for VMAP follows the Vector Product Format (VPF).

Level 1 resolution (VMAP 1) is a medium scale resolution and features a dataset that is divided into 234 geographical titles. However, only 55 of these titles are available for download from NGA. Some of the datasets that are available for download from NGA include the following: United States, Mexico, Libya, Costa Rica, Russia, and Iraq. The scale of coverage for Level 1 is 1:250,000 and Level 1 VMAP is only partly in the public domain.

Finally, Level 2 resolution (VMAP 2) is a large scale resolution, which is a scale of 1:50,000. In addition to the levels of resolution, VMAP geospatial data is topologically structured and separated into nine thematic layers: boundaries, hydrography, elevation, industry, physiography, transportation, utilities, population, and vegetation. Each thematic layer contains a set of files that describes the features in each layer, and each thematic layer is stored as a single coverage. VMAP is designed to be used and analyzed by a GIS (Geographic Information System) and can also be used to produce map background displays for a wide range of situations.

Various tools can be used to read and convert VMAP data. For example, VPFView, developed by NIMA, can be used to render simple plots and export GIS data to other GIS file formats. VPFView is available from NGA as part of the NIMAMUSE package. Another tool that can be used is OGR with ODGI driver. OGR is capable of converting VMAP format to standard GIS file formats, such as Shapefiles. Since NGA is a government agency, nearly all GIS data created by NGA is free and openly available in accordance with the Freedom of Information Act. Therefore, much of the VMAP data is offered as part of the public domain. Although GIS data is open to the United States public, governments in other countries still view this data as a state monopoly, and it is strictly prohibited for use by the public.

The National Geospatial-Intelligence Agency (NGA) is the creator of the VMAP database system and is a Department of Defense combat support agency. The goal of NGA is to provide accurate and timely geospatial information to support national security efforts. In addition to this, NGA provides its customers with access to the world's best geospatial and imagery intelligence. NGA was established in 1996 under the title of National Imagery and Mapping Agency, but changed its name in 2003 to reflect its expanded function in the areas of imagery and geospatial intelligence.

Premium Sources for Map Data

There are several vendors of premium map data available, such as Tele Atlas and NAVTEQ. The map data provided by these vendors is readily available for integration with ThinkGeo's mapping and GPS satellite-tracking products.

Tele Atlas provides digital maps and digital map data for Geographic Information Systems (GIS), Location Based Services (LBS), and automotive navigation systems. Tele Atlas's map databases cover 51 countries and are available in a variety of formats. In addition, Tele Atlas provides accurate map data to support commercial and government mapping applications. One of Tele Atlas's products in particular, Dynamap, provides raw mapping data for end users to develop professional maps. Dynamap provides highly accurate digital map data that can be used in many GIS applications.

NAVTEQ is one of the world's largest providers of premium digital map data. NAVTEQ digital map data is most commonly used in vehicle navigational systems that are sold in North America and Europe. In addition to use in vehicle navigation systems, NAVTEQ's map data is also commonly used in numerous GIS solutions around the world. NAVTEQ digital map data features road geometry and dozens of road attributes in over 40 countries.

NAVTEQ data provides an accurate representation of road networks and up to 160 attributes, such as areas of restrictive access, physical barriers and gates, turn restrictions, one-way streets, and relative road heights. Besides the automotive industry, GIS development, and internet navigation sites, NAVTEQ data is also used in express mail services, efficient field management services, emergency and government routing plans, and vehicle tracking applications.

NAVTEQ digital map data is regularly tested by field researchers who continuously drive roads around the world to ensure that NAVTEQ data reflects current real-world conditions. Finally, NAVTEQ offers its users regular updates for its digital map data and these updates can also be added to older digital maps.

Internet Resources for Map Data

There are two primary resources on the internet for reliable map data. These resources are geodata.gov and data.geocomm.com. Geodata.gov helps users find data and map services, develop maps, cooperate on data acquisitions, and browse community information. The geodata.gov site is essentially a Geographic Information portal that is open to the public so that users can easily acquire geospatial information and data from a single source.

When a user registers with the geodata.gov site, searches, maps, and geography can be saved for later use. On the website, geography can be easily accessed for local governments and geographic data for federal, state, and local government can be accessed. GIS developers and users can access a wide variety of map data, such as live data and maps, downloadable data, offline data, and map files. In addition, data is divided into several different categories, such as administrative and political; farming and agriculture; biology and ecology; cultural, society, and demographic; geological and geophysical; and oceans and coasts. Finally, geodata.gov offers users several free GIS software tools like ArcExplorer Web.

Geocomm.com is another commonly used GIS portal on the NET and is an online resource for free GIS data to use with GIS and CAD software applications. Geocomm.com also offers free downloadable software tools and demos to help users get started with their GIS applications. Some of the GIS data that can be accessed from geocomm.com include: Digital Chart of the World (DCW), Digital Raster Graphics, Digital Elevation Model data, Landsat Thematic Mapper data, and Digital Line Graph data. The mission of geocomm.com is to be an online leader of geographic products and services for GIS developers and enthusiasts. The geocomm.com website promotes open and free exchange of geospatial information between users of the site.

In conclusion, ThinkGeo products, such as Map Suite and Cygnus Track, rely on map data from a wide variety of sources for their mapping and geospatial applications. For example, the Map Suite products utilize TIGER®/Line data from the U.S. Census Bureau to expand their look and functionality. Reliable map data is essential for the building and rendering of unique and accurate maps. In order to help customers realize the goal of building accurate, reliable, and unique maps, ThinkGeo has a staff of dedicated GIS developers and software engineers with extensive GIS experience, which ensures that map data integration is smooth and trouble-free. In addition to this, ThinkGeo uses mapping data from only the most reliable and accurate map data sources in the world, such as the U.S. Census Bureau.

Creating ShapeFiles From Scratch in Map Suite 2.x

ThinkGeo — Mon, 25 Feb 2008 11:34:32 GMT

Map Suite has the ability to edit existing ShapeFiles, but what if you want to create your own? The code below should get you started, but if you want to explore more shapefile editing check out our EditShapeFile sample application included with the evaluation download.

Below is a very simple example of creating a point based shapefile from scratch. It adds three records and fills the value for the field "Name".

private DatabaseColumns Columns = new DatabaseColumns();
private DatabaseColumn Column1;
Column1.FieldType = FieldDataType.fdtString;
Column1.Length = 15;
Column1.DecimalLength = 0;
Column1.Name = "Name";
Columns.Add(Column1);
Map1.CreateNewShapefile(ShapeTypeEnum.Point, "C:\\thinkgeo\\temp", "Test", Columns);
Layer Layer = new Layer("C:\\thinkgeo\\temp\\test.shp", false);
Layer.BeginEdit();
int Shape1 = Layer.AddShape(new PointShape(-98, 19));
Layer.UpdateTableData(1, "Name", "Record1");
int Shape2 = Layer.AddShape(new PointShape(-97, 15));
Layer.UpdateTableData(2, "Name", "Record2");
int Shape3 = Layer.AddShape(new PointShape(-98, 20));
Layer.UpdateTableData(3, "Name", "Record3");
Layer.CommitEdit();

VB.NET

Dim Columns As New DatabaseColumns
Dim Column1 As DatabaseColumn
Column1.FieldType = FieldDataType.fdtString
Column1.Length = 10
Column1.DecimalLength = 0
Column1.Name = "Name"
Columns.Add(Column1)

Dim Column2 As DatabaseColumn
Column2.FieldType = FieldDataType.fdtDouble
Column2.Length = 5
Column2.DecimalLength = 2
Column2.Name = "Acres"
Columns.Add(Column2)
Dim strPath As String = "C:\Projects\ThinkGeo\"
Dim strName As String = "Steve"
Map1.CreateNewShapefile(ShapeTypeEnum.Polygon, strPath, strName, Columns)

Map1.MapUnit = MapSuite.Geometry.MapLengthUnits.DecimalDegrees

Dim Layer As New Layer(strPath & strName, False)
Layer.BeginEdit()
Dim Shape As New Polygon()
Dim dblacres As Double = 90.31
Dim shape1 As Integer = Layer.AddShape(Shape)

Layer.UpdateTableData(shape1, "Acres", dblacres.ToString)
Layer.UpdateTableData(shape1, "Name", "Record1")
Layer.CommitEdit()
Layer.BuildIndex()
Layer.BuildRecID("Recid", True)