We’ve already introduced MapServer and showed how to create a mapfile using GIS data. We will now introduce MapServer’s CGI functionality as a way to generate a map image. Later we will build on what we’ve learned to create a map using OpenLayers, a web mapping interface.

Introducing Mapserv.exe

At the heart of MapServer is a single file referred to as “mapserv”. With the MS4W package, it is a single executable found at C:\ms4w\Apache\cgi-bin\mapserv.exe. This file is the map production engine that uses a mapfile to generate a map image.

Mapserv.exe is usually accessed internally by MapServer-based packages such as ka-map or Mapscript. But it can also be called directly from a web browser as long as some required parameters are included.

Mapping from the Web Browser Address Bar

In order to demonstrate Mapserv.exe, we already need to have some data and a mapfile ready to use. We will be using the data and mapfile from our World Map dataset.

Open a web browser and enter the following: http://localhost/cgi-bin/mapserv.exe. If MapServer is correctly configured, you should see the following warning message:

This means mapserv.exe is working correctly so we can next tell it that we want to draw a map. Add ?mode=map to the address so the full address is http://localhost/cgi-bin/mapserv.exe?mode=map. Pressing enter again returns another message:

This is expected because we have not provided a mapfile to display. The next variable to add is named “map” and it’s value is the file path to our mapfile. For example, it could be: http://localhost/cgi-bin/mapserv.exe?mode=map&map=C:\world_mapfile.map. If a valid mapfile is entered the browser will generate an image such as this:

A full list of CGI MapServer parameters can be found here. For example, to generate an image of a specific map extent, the MAPEXT parameter can be used. In our example, we added MAPEXT -20 -20 20 20 in the browser to get an address like this: http://localhost/cgi-bin/mapserv.exe?mode=map&
map=C:\James\GIS\Data\World\world_mapfile.map&mapext=-20 -20 20 20. The image returned reflects the new extent.

Conclusion

Understanding how MapServer uses mapserv.exe to generate images will become more useful in our next post where we will setup a basic web mapping site using OpenLayers that will need to directly access the CGI functionality of MapServer.

Once the MapServer for Windows (MS4W) package with ka-Map is installed on your local machine, some new mapping functionality becomes available. One area that interests us is the ability to automatically generate a set of map tiles.

ka-Map Configuration

The first step in creating a set of map tiles is to configure ka-Map to point to a valid MapServer mapfile (see here for more on a mapfile). Navigate to this directory: C:\ms4w\apps\ka-map-1.0\include and open the file named config.php in any text editor.

This configuration file contains several parameters which you should be familiar with before creating our map tiles. We won’t change any of their values yet but it is important to understand what they do. First, on lines 73 and 74, the pixel size of each tile to be generated is defined:

$tileWidth = 256;
$tileHeight = 256;

Lines 106 through 110 define the most important parameters:

$aszGMap = array (
         'title' => 'GMap 75',
         'path' => '../../gmap/htdocs/gmap75.map',
         'scales' => array( 40000000, 25000000, 12000000,
                                 7500000, 3000000, 1000000 ),
         'format' =>'PNG'
 );

By default, ka-Map is setup to use the GMap application that we downloaded and setup in the first post. So the values for the title, path, and scales reflect that.

The path variable is relative based on the location of config.php (config.php is in C:\ms4w\apps\ka-map-1.0\include and the gmap75.map file is in C:\ms4w\apps\gmap\htdocs).

The scales array contains all the map scales at which the tiles will be generated. Determining which scales and how many scale levels is completely configurable based on the user’s preference. For now we will leave them as-is.

Lastly, the output image format is defined as PNG.

Precache.php

ka-Map is a web-based interface for viewing MapServer-based maps using map tiles. Normally, ka-Map generates only the necessary map tiles needed to show in the browser’s window. But there is a separate file, named precache.php, that also comes with the ka-Map that does generate all the map tiles for every scale of the map.

Navigate to the following directory: C:\ms4w\apps\ka-map-1.0\htdocs. Scroll through the list of files to find the file precache.php. The good news is this file does not need to be modified in any way. It relies solely on the config.php settings described above to determine what mapfile and map scales to use when creating the map tiles.

Running Precache.php

Readers are encouraged to first read over this article in the ka-Map wiki about precache.php. You don’t have to understand everything it discusses – just glance over the parameters needed to run precache.php.

Running precache.php requires returning to the world of DOS prompts and command line. It is important to follow these steps exactly as listed otherwise it may not work correctly.

1. Open a command prompt. On Windows, go to Start…Run and type cmd.
2. Type cd C:\ms4w\apps\ka-map-1.0\htdocs to go to the directory with precache.php.
3. Since precache.php is a PHP file, we need to run it using the PHP executable (php.exe). Fortunately this is already included with the MS4W package. Type C:\ms4w\Apache\cgi-bin\php.exe precache.php in the command prompt. We left out the required parameters on purpose here so you can see the usage instructions:

We won’t need to use -f, -m, or -s options but we do need to add the tile_url parameter. This is the web address (hence “_url”) to ka-Map’s tile.php file. Even though the file is stored locally at C:\ms4w\apps\ka-map-1.0\htdocs\tile.php, we need to enter a valid URL. The usage instructions suggest using http://localhost/ka-map/htdocs/tile.php but that didn’t work for us. Instead we will use http://localhost/kamap/tile.php.

1. Type C:\ms4w\Apache\cgi-bin\php.exe precache.php http://localhost/kamap/tile.php. Press enter the map tiles will be generated.

This process will take several minutes as all the tiles at each of the scale levels are generated. The command prompt will display information on each scale level. This information on meta tiles and tile counts is informative but not necessary to understand right now. In short, precache.php requests larger tiles (“meta tiles”) and then cuts them up to arrive at the final set of tiles.

Viewing the Map Tile Cache

Navigate to C:\ms4w\tmp\ms_tmp\kacache\gmap. Inside this folder should be a folder named for each scale level in the map. Inside each scale level folder our folders named __base__ and then a sub-folder named def. This is where the tile images can be found.

Because ka-Map tiles are generally only used internally and not designed for end-user interaction, there is a potentially confusing way to name tiles and tile folders. Anytime a folder or file contains the letters “t” or “l”, it means top or left. So instead of naming tiles with X/Ys or Row/Columns, ka-Map uses the “Left/Top” naming convention.

It also names each tile based on it’s pixel location and tile size. Since the config.php was set to output 256×256 tiles, each tile image will include top and left numbers based on multiples of 256. So if one tile is named t0l0.png, the adjacent tiles on each side would be named t0l256.png and t0l-256.png. Glance through the folders and view some of the individual tiles to get a sense of the tiling structure.

What’s the Benefit?

Traditional usage of precache.php is for improving the load times on a web mapping site by caching all the tiles ahead of time. For our objectives, having a complete set of pre-compiled map tiles means we can create a desktop application without including a GIS code library or GIS data. It also eliminates the extra processing time and would make deploying our applications easier. Instead of including extra DLLs and shapefiles, we simply need to include a folder of map tiles to run the application.

Conclusion

This post is probably the most technical topic we’ve covered to date. For now, simply understanding how to generate map tiles using precache.php is a what’s important. In the next post we will discuss the map tiles in some more depth, including how we can use them in other applications.

Continue to part 3

Python Installation

The Export to MapServer tool will only work if the Python programming language is installed on your computer. The latest version (2.5.1) of Python is required so we first need to download and install it here.

Open a QGIS Map

After the installation, go ahead and open a QGIS map. We will continue to use the world map project created in the previous posts. As a reminder, we have two layers in our map – a vector layer showing country outlines and a raster background image.

Export to MapServer

Under the File menu option, select the “Export to MapServer Map” item:

The window that opens requires you to input some information before creating the mapfile. First you need to select a location for the new mapfile. Then pick the QGIS project file that you will be creating it from (it does not automatically use the currently open project in QGIS). Provide a map name, enter the size, and make sure the units drop-down box matches the map’s units. Our map is only in longitude/latitude units so we chose dd (decimal degrees). We will skip the box covering the Web Interface Definition so our filled out menu looks like this:

Press Ok to run the export and the mapfile will be created.

Viewing the Mapfile

Find the created mapfile and open it in your favorite text editor. The mapfile is a structured document that contains groups of elements that begin with a name (e.g., MAP, PROJECTION, LAYER) and end with END. It also contains single-line attributes using the key-value syntax (e.g., NAME ‘World Map’, TRANSPARENCY 100, OUTLINECOLOR 0 0 0). It is very similar to an XML file but without the brackets and slashes.

For a complete reference on the syntax of mapfiles, check out their help page on the web. Even without reading the help file, most of the mapfile can be understood by simply glancing at the text. For example, our world raster image appears in the mapfile like this:

LAYER
    NAME 'world_raster'
    TYPE RASTER
    DATA 'M:\\World\\world_raster.tif'
    METADATA
      'wms_title' 'world_raster'
    END
    STATUS DEFAULT
    TRANSPARENCY 100
    PROJECTION
    'proj=longlat'
    'ellps=WGS84'
    'datum=WGS84'
    'no_defs'
    END
  END

It is easy to determine the between the LAYER and END tags, the raster is described with it’s name, type, file location, and projection information.

Our shapefile of world countries is slightly longer but similar:

LAYER
    NAME 'world_adm0'
    TYPE POLYGON
    DATA 'M:\\World\\world_adm0.shp'
    METADATA
      'wms_title' 'world_adm0'
    END
    STATUS DEFAULT
    TRANSPARENCY 100
    PROJECTION
    'proj=longlat'
    'ellps=WGS84'
    'datum=WGS84'
    'no_defs'
    END
    CLASS
       NAME 'world_adm0'
       STYLE
         SYMBOL 0
         SIZE 6
         OUTLINECOLOR 0 0 0
         COLOR 144 50 207
       END
    END
  END

The major difference between this and the raster file is the addition of a CLASS and STYLE element. They define the coloring of the countries using the OUTLINECOLOR and COLOR attributes.

Sometimes our mapfile doesn’t exactly match how QGIS had it displayed. In our QGIS map, we displayed the countries with a transparent fill so only the black outlines showed on the map. To make our exported mapfile match that, we need to remove the “COLOR 144 50 207″ line and save the mapfile.

Testing the Mapfile

There are various ways our mapfile could be tested in another application. The coolest example would be to go back to our Mapscript/XNA tutorials. The result of these tutorials was a C# program that uses XNA as the graphics engine and Mapscript (Mapserver’s API) to generate map images from a mapfile (download the project’s source code in this post).

In our program, we simply need to change the line of code where our mapfile path is defined to point to our new mapfile created from the QGIS export.

mapserver = new shMapserver(@"M:\World\world_mapfile.map", 600, 600);

Running the program will prove that our new mapfile works and allow us to zoom around the world.

Conclusion

QGIS is a free, easy-to-use, software program for viewing and exploring geographic data. The reason for discussing it in some depth is that if we want to start developing our own mapping applications, we need to begin acquiring GIS data and making our own maps. QGIS also gives us an easy way to produce MapServer mapfiles as we demonstrated above.

protected override void Update(GameTime gameTime)
{
    // check if a mouse click has occured
    mouse.Update();
    if (mouse.LeftButton == ButtonState.Pressed)
    {
        mapserver.ZoomMap(1, mouse.X, mouse.Y);
    }
 
    // check if a key has been pressed
    KeyboardState keyState = Keyboard.GetState();
    if (keyState.IsKeyDown(Keys.F))
    {
        graphics.ToggleFullScreen();
    }
    else if (keyState.IsKeyDown(Keys.Z))
    {
        mapserver.ZoomMap(2, mapserver.MapPixelCenter.X, 
                      mapserver.MapPixelCenter.Y);
    }
    else if (keyState.IsKeyDown(Keys.X))
    {
        mapserver.ZoomMap(-2, mapserver.MapPixelCenter.X, 
                      mapserver.MapPixelCenter.Y);
    }
    else if (keyState.IsKeyDown(Keys.C))
    {
        mapserver.ZoomMapFullExtent();
    }
    else if (keyState.IsKeyDown(Keys.Escape))
        this.Exit();
 
    // check if a new mapserver image needs to be generated
    if (mapserver.RefreshMap)
    {
        mapserver.UpdateMap(graphics.GraphicsDevice);
    }
 
    base.Update(gameTime);
}

Each option relies on our MapserverXNA class discussed in the last post. Since all the functionality is hidden within this class, coding our main program is very straightforward. Additionally, zooming in and out is performed with the help of our Image Swapping class we created in a previous post. This adds a fading in/out effect but none of this code is even visible in the main program.

As shown above, a mouse click invokes a pan of the map (click here for more information on zooming and panning with Mapscript). The mouse’s X/Y click coordinates will become the new center of the map. Within the MapserverXNA class, we added a shift effect when a pan occurs using the previously mentioned Image Swapping class. Upon the mouse click, the existing image is shifted and then the new image then just replaces it. This sliding effect is an alternative to the fading effect used for zooming b/c it wouldn’t make sense to pan the map and then fade in the new image.

The last portion of code added is in the draw method. Here we draw our map image, mouse cursor, and some text.

protected override void Draw(GameTime gameTime)
{
    graphics.GraphicsDevice.Clear(Color.White);
    spriteBatch.Begin(SpriteBlendMode.AlphaBlend);
 
    mapserver.DrawMap(spriteBatch, gameTime);
 
    mouse.Draw(spriteBatch);
 
    spriteBatch.DrawString(font, "Z = Zoom in", new Vector2(5, 4), Color.Black);
    spriteBatch.DrawString(font, "X = Zoom out", new Vector2(5, 16), Color.Black);
    spriteBatch.DrawString(font, "C = Full Extent", new Vector2(5, 28), Color.Black);
    spriteBatch.DrawString(font, "Click to pan", new Vector2(5, 40), Color.Black);
 
    spriteBatch.End();
 
    base.Draw(gameTime);
}

Conclusion

This post concludes probably the most complex project we have demonstrated so far. Some of the Mapserver-related code was not discussed because it has been covered in our previous projects (Mapserver – 10 Minute Tutorial, Mapscript Demo). The entire source code for this project is available to download below. The program’s requirements (C#, XNA, Mapserver, and a valid Mapserver map file) have all been discussed in our other projects. Questions and comments are always welcome at james [at] spatialhorizons.com.

MapserverXNA Class

We named the class MapserverXNA and the properties and methods look like this:

The properties include information on the map’s size (height, width, and center), the location of the map file, and a boolean value (RefreshMap) that tracks whether the map needs to be updated.

The methods include the ability to update the map (i.e. generate a new image from Mapserver) and draw the map onscreen. There are also two zoom methods: ZoomMap allows for zooming in, out, and panning while ZoomMapFullExtent returns the map to the full extent.

We won’t discuss in detail the code inside of this class. It is included in the source code download below so you are welcome to take a look yourself.

Using the MapserverXNA Class

The next step is to setup a XNA program to use the newly designed class. We could start from scratch but instead this project will loosely build off the structure of World Mapper project from a while back. It does follow the standard form of a XNA game application as discussed in a previous post. We also incorporated what we learned in our Mapscript Demo and our post on XNA font.

With our XNA game program setup, we added several more fields (private variables) to the main game class:

GraphicsDeviceManager graphics;
ContentManager content;
SpriteBatch spriteBatch;
shMouse mouse;
shMapserver mapserver;
SpriteFont font;

In the constructor, we then setup our mouse class and initialized the MapserverXNA class with a valid map file string and size in pixels.

public MapscriptXNA()
{
    graphics = new GraphicsDeviceManager(this);
    content = new ContentManager(Services);
 
    mouse = new shMouse();
    mapserver = new shMapserver(@"C:\ms4w\apps\gmap\htdocs\gmap75.map",
        600, 600);
}

In the initialize method, we resize the screen to match the map size:

protected override void Initialize()
{
    graphics.PreferredBackBufferWidth = mapserver.MapWidth;
    graphics.PreferredBackBufferHeight = mapserver.MapHeight;
    graphics.ApplyChanges();
    base.Initialize();
}

In the load graphics method, we load both the mouse cursor and font from using XNA’s Content Pipeline:

protected override void LoadGraphicsContent(bool loadAllContent)
{
    if (loadAllContent)
    {
        spriteBatch = new SpriteBatch(graphics.GraphicsDevice);
        mouse.Cursor = content.Load(@"Content\Textures\MouseCursor");
        font = content.Load(@"Content\Font\MapFont");
    }
}

We will continue in our next post with the rest of the application’s code but the entire source code can be downloaded below. For new readers, we encourage you to glance over our past projects or read the new FAQs page.

Continue to part 3

Quick Review

Mapserver is a map-rendering program mainly used for web mapping applications. It can also be used for desktop applications via it’s Mapscript API.

In our previous Mapserver and Mapscript posts, we used a sample dataset of Canada that can be downloaded here. Since it is freely available and easy to use, we will continue to use it in this project. We will cover making your own datasets for Mapserver in a future post.

Adding XNA

We already created a standard forms-based application for interacting with Mapserver. There were some buttons and the map image just switches upon refreshes. If the project were scored on presentation, it would receive low marks. Nothing stands out, the visual aspects are relatively limited and fail to draw the user in. Fortunately XNA, in addition to being a game development platform, also offers a great set of features for producing mapping applications with some graphical enhancements.

Using Mapserver in XNA

It is actually very easy to use Mapserver map images in XNA. Before we begin coding our project, let’s think about the steps needed to do so:

1. Our XNA Program requests a new map image. This request will occur upon startup and any time the user interacts with the map via zooming or panning.
2. Using the Mapscript API, a new map image needs to be generated (see Mapscript Demo 2 for more info). The map image can be returned as a memory stream or saved to a temporary image file in JPEG or PNG format.
3. The XNA program then loads the map image as a 2D texture and displays it on-screen (see XNA and GIS 2 for more info). Our image swapping example shows one way to produce fade in/out transitions we could use when switching map images.

The map image is displayed until another request is made and the process is repeated. Both the speed of Mapserver and XNA enable this process to take less than a second to complete.

We will start coding in our next post and rely on an object oriented design to create a C# class that completes the steps above automatically. Adhering to this type of approach ensures we can easily add Mapserver functionality to other future XNA projects without much hassle.

Continue to part 2

The main object in our program is Mapscript’s map object (mapObj). This object has a method called zoomPoint that we can use to zoom in or out. The method looks like this:

zoomPoint(int zoomfactor, pointObj imgpoint, 
      int width, int height, rectObj extent, rectObj maxextent)

In our program, we simplify things by only allowing the user to zoom in or out on the center of the map. A single zoom function can be used for both zooming in and out:

public void ZoomMap(int zoomFactor)
{
    m_map.zoomPoint(zoomFactor, 
          new pointObj(picMap.Width / 2, picMap.Height / 2, 0, 0), 
          picMap.Width, picMap.Height, m_map.extent, null);
    RefreshMap();
}

The zoomFactor value depends on the action. Values greater than 1 zoom in, values less than 1 zoom out. In our case, clicking on the Zoom In fires this code:

ZoomMap(2);

while zooming out is the opposite:

ZoomMap(-2);

Panning

Panning the map is very similar to zooming except that this is controlled by clicking on the map. In fact, we can use the same zoomPoint method as we discussed above. The difference being when the zoomFactor is 1, the map remains at the same scale and only changes location.

Capturing a mouse click on the map (which is really our picture box control) is as simple this:

private void picMap_MouseClick(object sender, MouseEventArgs e)
{
    //--> pan map based on mouse click coordinates
    m_map.zoomPoint(1, 
         new pointObj((double)e.X, (double)e.Y, 0, 0), 
         picMap.Width, picMap.Height, m_map.extent, null);
    RefreshMap();
}

Conclusion

The source code is available to download below so feel free to test out the application as long as you have a valid map file and data available. There is still a lot of room for improvement on this application, including more functionality and error checking, but we need to move on to bigger and better projects. The primary purpose of this project was to demonstrate how Mapserver (via Mapscript) could be used to generate maps for a desktop mapping application. Our next demonstration project involves improving the visual aspects of our program in a way that hasn’t been done before. Stay tuned.

const string MAP_FILE = @"C:\ms4w\apps\gmap\htdocs\gmap75.map";
mapObj m_map;
rectObj m_fullExtent;

Both are Mapscript objects. The first (m_map) is our map object that will be the primary class used in this project. The second will simply remember the extent of the map upon startup, which is usually also the full extent of the map.

In the form’s constructor method, we setup our map to match our picture box size and the define the full extent:

m_map = new mapObj(MAP_FILE);
m_map.width = picMap.Width;
m_map.height = picMap.Height;
m_fullExtent = new rectObj(m_map.extent.minx, m_map.extent.miny,
                   m_map.extent.maxx, m_map.extent.maxy, 0);

Mapscript’s map object allows us to access Mapserver and generate map images. Here is one way to generate an image and load it into our picture box control. This code is based off a great Mapserver tutorial found here.

imageObj image = m_map.draw();
byte[] img = image.getBytes();
using (MemoryStream ms = new MemoryStream(img))
{
  picMap.Image = System.Drawing.Image.FromStream(ms);
}

Similarly, to generate a legend image:

imageObj legend = m_map.drawLegend();
byte[] img = legend.getBytes();
using (MemoryStream ms = new MemoryStream(img))
{
    picLegend.Image = System.Drawing.Image.FromStream(ms);
}

Our application also has a sidebar that displays a legend that lists each layer and a check box displaying whether the layer is on or off. Each time the map is updated, this layers list needs to be updated by looping through the map’s layers and finding their visibility. A TreeView control is used to display the layers.

for (int i = m_map.numlayers - 1; i >= 0; i--)
{
    layerObj layer = m_map.getLayer(i);
    TreeNode node = new TreeNode(m_map.getLayer(i).name);
 
    if (layer.status == (int)mapscript.MS_ON)
        node.Checked = true;
    else
        node.Checked = false;
 
    trvLegend.Nodes.Add(node);
}

The code samples above are each placed into separate functions appropriately named RefreshMap, RefreshMapLayers, and RefreshLegend. They will be called when the program starts up and each time the user interacts with the map. The last piece of the puzzle, adding the zooming and panning functionality, will be covered in the next post but the entire source code can be downloaded below.

Continue to part 3

Today’s project will build off that setup by creating a small desktop application that uses MapServer’s ability to generate map images. Since MapServer is just a program (mapserv.exe) and some required DLLs, it is possible to create stand-alone applications that don’t have a web component.

Introducing Mapscript

In their own words…

MapScript provides a scripting interface for MapServer for the construction of Web and stand-alone applications. MapScript is used independently of CGI MapServer, it is a loadable module that adds MapServer capability to your favorite scripting language. MapScript currently exists in Php, Perl, Python, Ruby, Tcl, Java, and C# flavors.

This means we can use Mapscript in Visual C# Express to access MapServer’s capabilities to draw and query maps. The maps generated are just images so we can easily integrate them into a standard Windows application. So let’s go ahead and create a desktop mapping application powered by MapServer.

Create a MapServer Stand-alone Viewer

Here are the steps to creating a MapServer application using Mapscript in C#. We will assume that a valid MapServer map file is already setup and ready to use. See our last post on how to download and setup a sample mapping application.

Step 1 – Create a Windows Application in Visual C# Express

Create a new Windows Application and add some basic controls to the form. I first added some buttons for zooming in, out and to return to the full extent of the map. A tab control was added on the side to contain both a list of the map layers and an image of the legend. Most importantly, I placed a large picture box control on the form to serve as the map display area.

At this point, I went ahead and compiled the application so the bin\debug folder would be generated within our application’s directory. Step 2 explains why we need that folder right away.

Step 2 – Adding the Mapserver DLLs

Stand-alone Mapserver applications need a number of DLLs to be present in the folder where the executable (*.EXE) will be generated. Luckily, the MS4W package ships with everything we will need. Navigate to the C:\ms4w\Apache\cgi-bin folder and note all the DLL files that are present there. There are approximately 54 in total so just go ahead and copy them all and then paste them into the bin\debug folder of your application. Some DLLs are unnecessary or only needed in certain situations but it’s easier right now just to copy them all.

Next, look in the C:\ms4w\Apache\cgi-bin\mapscript\csharp folder and copy the two DLLs there – mapscript.dll and mapscript_csharp.dll. Paste both of these into the same debug folder as above. Finally, back in the C# application, add a reference to the mapscript_csharp.dll only using the Tools…Add Reference… menu option. All of the other DLLs just need to be present in the folder.

Now were are ready to code in the map functionality. Because we referenced the mapscript C# DLL, we have access to an API for interacting with Mapserver.

Step 3 – Coding with Mapscript

A valid Mapserver application (i.e. GIS data sets and a map file) is still required but we can use the free sample application we setup in the last post. Mapserver applications run on a configuration file referred to as a map file (*.map). So this is the first piece of information we need to add to our form.

const string MAP_FILE = @"C:\ms4w\apps\gmap\htdocs\gmap75.map";

This file path is the only variable that our application will need to know before running. All other code we add is independent of any specific map file or dataset. So if you want to use your own data, feel free to change the value in the source code below.

To Be Continued…

There is still a lot of coding to discuss in the next couple of posts but for those of you can’t wait, the complete source code of the application is available to download below along with a screenshot of the program running. The download includes the Mapserver DLLs so the program should compile and run right away assuming the MAP_FILE constant is pointed to a valid map file. Comments and questions are always welcome at james [at] spatialhorizons.com.

Continue to part 2

Most of our recent posts have focused on topics relating more to the components of a mapping application then on the maps and data. This post begins the first of several posts discussing free and open source mapping software applications. After introducing each software, we will explore various ways to create applications around them.

Introduction to MapServer

One of the most popular open source GIS applications is MapServer. Initially developed by the University of Minnesota, MapServer has evolved into a fast and easy-to-use internet map server.

“MapServer is an Open Source development environment for building spatially-enabled internet applications. MapServer is not a full-featured GIS system, nor does it aspire to be. Instead, MapServer excels at rendering spatial data (maps, images, and vector data) for the web.” – http://mapserver.gis.umn.edu/

Create Your Own Web Mapping Site in 10 Minutes

We just need to setup MapServer to run on a local machine for now and the best way to do that is to use MapServer for Windows (MS4W). This package is a all-in-one web mapping environment. It comes complete with Apache Web Server, PHP, MapServer, and other open source GIS utilities. Here’s how to set it up and add a “Google Maps”-like interface (using ka-Map) in under 10 minutes . I won’t describe the details of how everything interacts because you don’t really have to know right now. It just works.

1. Download the MS4W PHP5 Base Installer v2.2.6 (Sept 18,2007) from here.
2. Unzip the file to the root of your C:\ drive and this will create a folder C:\ms4w.
3. For some initial data, download the PHP/MapScript Sample Application here. The zip file is named gmap_ms4w_ms410.zip.
4. Again, unzip this file at the root of your C:\ drive and it will automatically be placed into the folder C:\ms4w\apps\gmap.
5. Download the ka-Map Javascript API from the same page. This file is named ka-map-ms4w-1.0.zip.
6. Again, unzip this file to the root of your C:\ drive and it will automatically be placed into the folder C:\ms4w\apps\ka-map-1.0.
7. Navigate to C:\ms4w and double-click on the file named apache-install.bat. In one-click, you’ve setup your web server and MapServer is ready to use.
8. Open your web browser and goto http://localhost/. You should see an Introduction to MapServer 4 Windows page.
9. Scroll to the bottom of the page and click the ka-Map Sample Interface link. This will load up the sample application we downloaded in step 3 using the ka-Map interface. The map should look like this:

Congratulations! You’ve just setup a mapping website. In short, ka-Map is basically a web page front-end for MapServer that is similar to Google Maps. MapServer is used to generate map images in the form of map tiles and ka-Map then presents them to the user so they can pan, zoom, identify, and search the map. More details to follow in later posts.

Continue to part 2