(source)

What's nice about this is that it is all built into a single layer element. Now, you can't do this directly in cumberland map xml, but you can still achieve much of this functionality. The trick is to just duplicate the layer using different symbology:

This draws the layer twice, giving us our complex symbol effect:

complex line symbols

There are additional variations that could be done with this, such as drawing a dashed/dotted line on top of a solid line and so forth. Full demo and source of this map is here.

On a side note: Isn't cumberland xml so much cleaner than ArcXML? Excessive use of attributes is an XML no-no. Let the xml schema take care of preventing duplicates.

The advantage of this is you can set styles that are enabled at higher scales (more zoomed out) that will draw simpler features. These look better. The SimplifyTolerance is in the data's units and will filter out vertices less than it. For example, I have Florida counties data in meters:

As the tolerance increases, the polygons look smoother. The trade-off is accuracy as you can see, and by a tolerance of 12,800 meters, the features are indistinct polygons. Finding the right value is an art, but definitely worth the work:

before:

after:

XML Schemas express shared vocabularies and allow machines to carry out rules made by people. They provide a means for defining the structure, content and semantics of XML documents.

One cool thing is that both MonoDevelop and Visual Studio (and I am sure others) provide tag completion and validation for them. This is very nice when you have an arbitrary xml format such as I do for cumberland maps.

Since I have no WYSIWYG editor like ArcMap or something, it is kind of tough to get started building a map. Xml schema provides a way to speed this process up. So, I used Xsd.exe to generate a schema from one of my maps, and then extended it by hand. It's available in the source here.

Now I'll just run through a quick example with the ubiquitous Visual C# Express:

First, create a project. Next, add a New item->Xml File. When this opens we'll get an XML menu item. Select 'Schemas'. This will open a dialog listing all available xml schemas, we want to add ours. Click the 'Add' button and select the above-linked cumberland.xsd (which you will need to download). The schema will now show up in the schemas:

Press 'Ok' and if you go back to your xml document, and type '<', you should see intellisense pop up with the 'Map' element! Press tab and it should complete the element and add the namespace. From there, you can create your map without having to refer to any wiki page. It will complete tags, show warnings when you are missing required elements or when elements contain invalid values:

And list elements when the values are restricted:

sweet.

I mentioned the frustrum, which is how we want to represent the 3D space and project it onto our 2D computer screen. Well, if we stand on the x axis it would look like so:

the frustrum on the x axis

The near and far clipping planes (zNear/zFar) are not pictured. For our purposes, they can be 1 and Integer.MaxValue, respectively. Neither is the aspect ratio, which will just be set to the aspect ratio of our window (width/height). That leaves us with the Field of View Y. We can start that at a value of 90.

I've placed the map in the frustrum, and as you can see, if we want to zoom to the full height of the map, we need to calculate z. Now, from the diagram, we can create a right triangle from the camera eye, the center of the map, and the top-center of the map. From there it is simple trigonometry:

The X/Y coordinate of the eye/camera is simply the map center, so now we know where to put the camera in 3d space to frame our 2D picture. We can also now acquire the map scale:

Accounting for window resizing

I've mentioned the field of view Y, but not X. Why is that? Well, the field of view X can be changed by changing the aspect ratio. That is, if the field of view Y is fixed, and the aspect ratio changes, then the field of view X must change. This causes problems in window resizing. Say, we expand the window in height, but not in width, since the field of view Y is fixed, we have to shrink the field of view X, which will have the effect of zooming the map in.

The solution is that we must adjust the field of view Y on every window resize by reversing our calculation to get the z value:

Enough math already!

Now we have the math to interact with our map. We can zoom/pan/etc. by moving our 3d coordinate (eye) in space. If we want to work backwards and figure out our extents from our point, we can simply reverse the function for discovering eye.Z above.

The final post in this series will summarize this topic and how it will be integrated in the next version of Appomattox.

Note: The source code from this post is available here.

labels in action

Also, Go Gators!

As always, a demo is up.

The TileProvider class has a new TileConsumer, VirtualEarth, and the tilepyramider now excepts a new 've' argument to its consumer option. This will create a directory full of images named by their quad key. Then you'll just need to wire up some script:

Create the map div and call your method:

And you're good to go! You'll need to build from SVN to get this.

You could use this tool to load up a subset of your data from postgis or sql server and pass it on to a customer with your own specialized symbology. A future improvement would be to allow importing of kml so that people could make edits in google earth and then load the changes into your database.

You'll need to build from SVN to get this.

Check out a demo.

It's pretty simple to set up. There is a new TileConsumer, TileMapService. tilepyramider has a new 'consumer' option you can set to "tms", and it will handle the rest, including creating the tilemapresource.xml file. (There are some properties in this file you'll need to update manually if you want it to be accurate)

OpenLayers

Currently, a TMS has to have an EPSG of 4326 and worldwide extents to work in OpenLayers (source). This means you can't clip to a certain region, so the above example generated a lot of empty tiles. Given that your map is projecting to epsg 4326, you'll run something like:

Then you'll deploy the resulting 'tms' directory to your website and wire up a page with the following script:

Add a script reference to OpenLayers:

Call initialize() on load and add your map div:

That's it! You'll need to build from SVN to get this.

Which is good, but we walk up to it and I'm just confused. What am I a looking at? It takes me a second to orient myself. Here is the map (complete with my annotations):

There a couple of issues:

1. You are looking at the map which is to the east, but the map is north/south, so it is disorienting. This could be fixed by moving the billboard so that you are facing north when you read it.
2. The trail which you are probably going on is not actually on the map!. Doh!

I think it's a really elegant and simple API for drawing maps, and it's also under the awesomest, most reasonable, licensing scheme there is.