Learn about the categories

By Charlie Frye, Esri Chief Cartographer

Category Description
ArcGIS Methods Use of ArcGIS to accomplish specific cartographic tasks.
Cartographic Effects “What”, “why” and “how” about achieving special cartographic techniques.
Cartographic Design Visual hierarchy, figure-ground, legibility, visual clarity, visual flow, etc.
Symbology Assignment of qualitative and quantitative meaning to signs (color, size, shape, etc.)
Cartographic Representation Use of cartographic representations in the map production process.
Data Modeling Modeling GIS data for mapping and geoprocessing.
General Information Announcements and information about Mapping Center, cartographic resources and events, etc.
Labeling Type elements (font, size, form, etc.) and type placement.
Map Data Specific themes of data, e.g., transportation, hydrography, cultural, etc.
Map Elements Scale bars, north arrows, legends, tables, graphs, text blocks, etc.
Maplex Use of the Maplex Label Engine.
Page Layout Arrangement of the content on the page.
Publishing Printing and output for print, printing press, digital static or digital interactive media.
Posted in Mapping | Tagged , | Leave a comment

Using rotation angles for markers, lines, or polygon fills

By Aileen Buckley, Mapping Center Lead

Rotation Angles - Thumbnail

If having the proper orientation, or rotation angle is an important characteristic of your symbols, it is important to make sure your symbols accurately display the phenomenon they depict. Thus, I thought it would be a good idea to review the use of rotation angles in ArcMap.

You have probably set rotation angles for symbols, (markers, hash lines, and Line or gradient fills), your data frame, and maybe even for point features which can be rotated by the angle stored in a field. Most of you already know your own data well, but if you’ve
ever downloaded data or inherited legacy data, you may not know which way the rotation angles were calculated (so if you publish data, remember to invest a few minutes in authoring the metadata).

ArcGIS has tools and functionality that may use any of three rotation methods:  Geographic, Arithmetic, and Graphic.

Continue reading

Posted in Mapping | Tagged , , | 3 Comments

What's the Weather? Find out with the Weather Finder

Another useful and interesting custom task (written by Michael Waltuch) is found in the Community Showcase section of the Explorer Resource Center. It’s a good example of a custom task that leverages an available Web service for use within Explorer.

Weather Finder locates the nearest weather station to a specified location and reports its most recent weather observations. The task is based on a reverse geocoding web service located at GeoNames.org. To learn more about GeoNames go to their web site and see the service description.

To use the task, first go the the Community Showcase, locate the task, and click to add it to Explorer.

We can activate the task and click on our map to find the current weather, or we can use a result as the input location. Let’s use Find Place to locate Manhattan.

Now that we’ve found Manhattan, we’ll right click the result and use Send To and choose Weather Finder from the list (we also could have done this via the result popup window).

Now that Manhattan is the Weather Finder search location, click Find. The nearest weather station will be located, and we’ll automatically zoom to it. In this case the nearest weather station is found in Central Park.

The popup window associated with the weather station includes a link to the National Weather Service’s Telecommunication Operations Center which includes a 24 hour summary for the weather station.

You can also click the link in the popup to show the National Weather Service’s Web site for this location. Here we see that currently it’s a balmy 57 degrees in Central Park under overcast skies, with 6-mile visibility and calm winds.

Posted in Uncategorized | Tagged , , , | Leave a comment

Time Navigator Custom Task

Richie Carmichael (of ESRI’s Applications Prototype Lab) posted a Time Navigator custom task for Explorer a while back. The task has gone through several iterations and improvements, and the current version (including source code) can be found at ArcScripts.

There’s also a YouTube video posted on the task, and Richie also includes a discussion of it at his blog.

We used it the other week for animating some of the fire spread data that we’ve been compiling. Here it is in use:

You’ll also find a number of other tasks for Explorer at ArcScripts, and we’ll be adding a direct link to ArcScripts from the Explorer Resource Center soon.

Posted in Uncategorized | Tagged , , | Leave a comment

Identify on a single layer in the Web Mapping Application

Robert Burke, an instructor for ESRI Educational Services and author of Getting to Know ArcObjects, contributed the following post.

In teaching ArcGIS Server developers over the last few months, one question I
often get is, “How can I change the Identify tool to work on just one
layer?” For example, my published map service has 40 layers on it, but I only
need my users to identify one or a few of the layers.

These instructions are for a Web Mapping Application created with ArcGIS Server
for the Microsoft .NET Framework. It can be an application created in Manager,
or one created with Visual Studio 2005.

First, you have a published map service and need to know the order of layers in
that map service. Use ArcMap to open the map document (the MXD or PMF file) for
the service in question and list the layers in the map’s published data frame.
Here my data frame has the default name, called Layers, and contains five
layers, but two are in a group layer called Buffer Points.

Buffer Points
InputFeatures point layer
Output Feature Class

Now determine the index position of these layers in the MXD file. I have a group
layer, so that influences the index numbers for each layer. Normally the top
layer is index 0, the one under it Index 1, the one under that 2, and so on.
But with a group layer, the entry for the group gets an index and then layers
in the group each have their own index numbers. Identify can use these index
numbers when looking for features to be identified. The numbering for my layers
is as follows.

(0) Buffer Points
(1) InputFeatures point layer
(2) Output Feature Class
(3) Streets
(4) CityLimit
(5) Parcels

Layers gets no index position because it is not a layer, it’s just a data frame.

Now that you know the layer index numbers, you are ready to go to the code for
the Identify tool. Use Visual Studio 2005 (or Visual Web Developer Express,
free download from Microsoft
) to open the Web Mapping Application
website you want to modify. In the website, open the MapIdentify.vb or
MapIdentify.cs code file in the project’s App_Code folder. In the code, locate
the Identify function.

Public Function Identify(ByVal queryString As NameValueCollection) As String

public string Identify(NameValueCollection queryString)

Scroll down to about the midpoint of the Identify function and locate the
following lines of code.

Dim ds As DataTable() = Nothing
ds = query.Identify(mapFunc.Name, mapPoint, m_IdentifyTolerance, m_idOption, Nothing)

DataTable[] ds = null;
ds = query.Identify(mapFunc.Name, mapPoint, m_IdentifyTolerance, m_idOption, null);

After the first line with the DataTable, and before the Try statement, add in an
extra line of code. As shown below, the new line creates a one-dimensional
string array variable and immediately adds two string values to it. Here the 3
and 5 represent the index positions of layers in the map, Streets and Parcels.
Here we are altering the Identify tool to select features from just these two
layers. You have one more step before testing the tool.

Dim ds As DataTable() = Nothing
Dim lids() As String = {"3", "5"}
ds = query.Identify(mapFunc.Name, mapPoint, m_IdentifyTolerance, m_idOption, Nothing)

DataTable[] ds = null;
string[] lids = { "3", "5" };
ds = query.Identify(mapFunc.Name, mapPoint, m_IdentifyTolerance, m_idOption, null);

On the last line of code, the Identify method is being used on the map’s
QueryFunctionality. The method has 5 arguments; the last argument represents a
string array of the layers that you would like to identify. In this case
however, the keyword Nothing (null) is currently in place. When Nothing (null)
is passed here, the identify works with all layers.

The first argument on the Identify method is name of the map functionality. The
second argument for Identify represents the point where the user clicked on the
map. If you look above in the code you will see that the initial point is
returned in screen pixel units and is then converted into map units. The third
argument represents a tolerance number in pixels. This is the search distance
used by Identify from the point where the user clicked. A pseudo-buffer zone is
created x number of pixels around that point. The tolerance is an integer, so
if you have a 3 in there, a search will be made using a three-pixel buffer
around the user point. The fourth argument has three possible Identify option
values: AllLayers, VisibleLayers, and TopMostLayer. The Identify method uses
the VisibleLayers choice.

In the Identify method, replace the Nothing (null) keyword with the String
Array you created above.

Dim ds As DataTable() = Nothing
Dim lids() As String = {"3", "5"}
ds = query.Identify(mapFunc.Name, mapPoint, m_IdentifyTolerance, m_idOption, lids)

DataTable[] ds = null;
string[] lids = { "3", "5" };
ds = query.Identify(mapFunc.Name, mapPoint, m_IdentifyTolerance, m_idOption, lids);

You can now run the application and test the Identify tool. Provided you have
layers at index positions 3 and 5, the tool will only work with features from
those two layers and ignore the others.

Now if you just want to identify the Streets layer, just alter the array
definition and only include one layer index number. In this example Streets is
at index position 3 so you will omit the 5 for the Parcels layer.

Dim ds As DataTable() = Nothing
Dim lids() As String = {"3"}
ds = query.Identify(mapFunc.Name, mapPoint, m_IdentifyTolerance, m_idOption, lids)

DataTable[] ds = null;
string[] lids = { "3" };
ds = query.Identify(mapFunc.Name, mapPoint, m_IdentifyTolerance, m_idOption, lids);

If you run the code above, only features from the Streets layer will be
identified and the other layers will be ignored.

Posted in Services | Tagged , , , | 14 Comments

Creating street name indexes

By Charlie Frye, Esri Chief Cartographer

Sample of a portion of a street name index

We received a suggestion to write a blog entry on this topic from Anna Schwabedal, who is a technical sales representative for Esri Germany.  Anna gave us a rough idea of how this works and I was able to use that when this topic came up through Ask a Cartographer recently, and I’ve worked on it a bit since then in order to write this. Continue reading

Posted in Mapping | Tagged , , , | 29 Comments

Deconstructing the map cache tiling scheme (Part I)

In ArcGIS Server map caches, the tiling scheme defines how the map is broken up into a grid for creating tiles. Today’s post gives some of the terms you need to know when working with the tiling scheme. An upcoming post will discuss how to work with the tiling scheme programmatically.

Tiling scheme origin

The tiling scheme origin is the upper-left corner of the tiling scheme grid. The tiling scheme origin doesn’t usually represent the point where tiles begin to be created. Tiles are only created when the upper-left corner of the map, or map origin, is reached. In the diagram below, notice that the tiling scheme origin defines where the grid begins, but tiles are only created in the parts of the grid that cover the Full Extent of the map.

Tiling scheme grid

In most cases, you should keep the default tiling scheme origin chosen by the software. The default is the upper-left point of the coordinate reference defined by the map document. If no coordinate reference is defined in the map document, the tiling scheme origin defaults to a point far beyond the upper-left of the extent of all of the layers in the map.

If you change the tiling scheme origin to something other than the default, be aware that tiles can be created only in the map area to the lower-right of the tiling scheme origin. If you want to cache only a certain area of your map, creating your cache based on a custom full extent is a better option than changing the tiling scheme origin.

Using a common tiling scheme origin for all of your caches ensures that your caches can overlay each other successfully in Web applications.

Tile width and height

The default tile width and height is 512 pixels. You can choose any width and height that is a power of 2, but it’s recommended that you use 128, 256, or 512. If you are building a cache that will overlay another cache, be sure to use the same tile width and height for both caches.

Choosing a smaller tile width and height may improve performance of the application requesting tiles from the cache, as less data will need to be transferred. However, smaller tile size results in a larger cache size and longer creation time. Because the default Windows disk block size is 4 kilobytes (k), small tiles that may only be 1k in size will actually use 4k. A larger tile might be 4k in size and fit perfectly in a 4k block. Therefore, four 1k tiles use 16k on disk, whereas the single 4k tile covering the same area only uses 4k on disk. With large numbers of tiles, this difference can become significant.

Tile size on disk compared

The above image demonstrates how smaller tiles can require exponentially more size on disk than larger tiles.

-Sterling Quinn

Posted in Services | Tagged , , | 5 Comments

About the Weather style

By Jaynya Richards, Esri Research Cartographer

Weather - Examples of wind barb symbols

The Weather style supports creating several common weather charts. These charts depict sky conditions, wind speed & direction, and precipitation. The symbols are based on weather and climate related maps and graphics designed by staff at the Center for Ocean Land-Atmosphere Studies (COLA). COLA is a center jointly supported by NOAA, NSF, and NASA. This Weather style also has symbols for weather station models (Surface, Upper, Forecast), cloud cover, station wind, pressure fronts, and precipitation. Continue reading

Posted in Mapping | Tagged | Leave a comment

Education Community Blog Site on Explorer

The ESRI Education Community site is a great resource, full of interesting and useful information (and not just for educators). The site also includes a blog, and more than a few Explorer-related posts. One is George Dailey’s Explorer-based tour of Aussie educator Malcolm McInerney’s world travels.

Many more can be found by searching for the tag “AGX.”

We appreciate the support of the Education Team and Educators.


Posted in Uncategorized | Tagged , | Leave a comment

EditorTask customization guide and sample

In this post, Rex Hansen describes how to customize the .NET Web ADF EditorTask control and provides a downloadable sample.

While the EditorTask includes a comprehensive set of out-of-the-box capabilities, many Web editing solutions require customizing the behavior of the EditorTask to satisfy user specific requirements. The EditorTask offers two options for developing a custom solution:

  1. Using the out-of-the-box EditorTask, add custom functionality by handling EditorTask events in a page.
  2. Create a custom Web control by subclassing the EditorTask and its child controls.

Option 1 is designed for convenient access to standard EditorTask events in a Web application. Option 2 is more complex, but provides comprehensive access to the implementation details (which includes events) of the EditorTask and its subcomponents. It also enables you to package a Web ADF editing solution as a redistributable custom EditorTask control. In either case, it is important to understand the existing structure of an EditorTask. At run-time the EditorTask creates two visible container controls: the Editor and EditorSettingsPanel. The Editor is a composite control that contains either a VersionIDPanel or a set of editor panels and other controls to edit feature layers. The EditorSettingsPanel is a type of EditorPanel that contains a SnappingPanel and SelectionPanel. The class type and naming of these components will be important when working with EditorTask events or subclassing them in a custom EditorTask control.

Panel Structure and Naming

This section provides a visual guide to the class type and unique control id for notable components packaged with the EditorTask. For each component, the class type is listed above the unique control id, listed in quotes.

If an editable layer is versioned and more than one version is available for editing, the VersionIDPanel will be displayed in the Editor when the EditorTask is initialized at runtime.


The EditorTask contains an Editor which represents the primary visible control that contains other editing controls. The Editor contains a drop down list to select an editable layer. The main toolbar contains a set of tools and commands to manage the selected features in the active edit layer. A set of commands to manage edit operations may be included depending on the type of layer being edited and the map service in which it is accessed. When editing a non-versioned feature layer in a pooled service, the main toolbar will not contain an Undo, Redo, or Save button. When editing non-versioned data in a non-pooled service, the Undo and Redo buttons will not be available (the Save button will be available). The main toolbar can be customized.

Editor panels 

The Editor also contains a set of panels to create and modify features and attributes. The CreateFeaturePanel contains one or more tools to create a new feature depending on the active edit layer feature type. It contains a toolbar that cannot be customized. The EditExistingFeaturesPanel contains a number of tools and commands to modify existing features, packaged in two toolbars; GeometryToolbar1 contains items to modify entire features while items in GeometryToolbar2 were designed to manipulate feature vertices. Both toolbars can be customized. The EditAttributesPanel lists the attributes of the current set of selected features. Since only one feature’s attributes can be visible at any time, paging will be enabled when more than one feature is selected. The visibility and editability of attributes can be modified via attribute filtering. The attribute labels and textboxes are generated internally by the EditAttributesPanel and are not available for explicit customization.


The EditorTask also contains an EditorSettingsPanel which can be initialized via the Editor at runtime and is designed to compliment actions initiated by Editor panels. The EditorSettingsPanel contains two panels: a SnappingPanel and SelectionPanel. The SnappingPanel panel provides the ability to change snapping rules and snap tips display at runtime. The SelectionPanel provides the end user with the ability to modify selection behavior when using the select tool in the Editor’s main toolbar. Both panels are not designed to be customized. However, like the Editor, the EditorSettingsPanel is designed to allow the addition and/or removal of panels.

Customization Categories

The EditorTask was explicitly designed to support customization in the following distinct, but related categories:

  • EditorTask events
  • Attribute Filtering
  • Custom Editor Tools
  • Custom Editor Panels

Recall that there are two options for developing a custom EditorTask solution; handle events on an out-of-the-box EditorTask control or subclass the EditorTask and its subcomponents. Both options are demonstrated in the example provided, within the context of each category.

Option 1 uses an out-of-the-box EditorTask control and EditorTask events within the context of the pagecontrol lifecycle to implement custom capabilities in each category. The diagram below highlights where these categories can be leveraged with Option 1. Note that you can add event handlers during Page or EditorTask control lifecycle events (e.g Init, Load).

Option 1 

Option 2 demonstrates how to subclass existing EditorTask controls, override members, create new custom components, and construct a redistributable EditorTask component. All customization capabilities present in Option 1 are available with Option 2, plus those capabilities that are only available within a subclass solution (e.g. protected members). The diagram below highlights where the implementation of each customization category may occur when extending the EditorTask.

Option 2

What’s in the sample

To get the sample, download one of the following based on your preference for C# or VB.NET:

Two projects are packaged with the sample:

  • A class library project (CustomEditorTask_<language>) that contains the classes and content needed to create a custom EditorTask control. Note the following customizations:

    1. On initial load of the custom EditorTask, attributes for the “Tentative Assessed Parcels”, “Address Points” and “Water Bodies” layers are filtered for display.
    2. On post tool execute, if a feature was created or modified in the “Tentative Assessed Parcels” layer, the time of the edit is written to respective fields in the feature class.
    3. The EditExistingFeaturePanel has been replaced by a custom Editor panel. The custom panel subclasses EditExistingFeaturePanel and adds two custom Editor tools, clip features and convert polygon to polyline.
    4. A set of custom properties on the EditorTask define if map units should be used for snapping. If true, a custom EditorSettingsPanel replaces the existing default panel. The custom panel also contains a custom SnappingPanel which contains the logic necessary to snap using map units (pixel tolerance changes with map scale).
  • A Web project (CustomEditorTaskWebApp_<language>) that contains two pages and a set of custom components (Editor tools and panels) in the App_Code folder. One page includes a reference to the custom EditorTask control created in the aforementioned project. The other page contains an out-of-the-box Editor task which is customized by handling events on the EditorTask. Both pages handle the release of server context for non-pooled services via a callback when the browser is closed. Note the following customizations to the out-of-the-box EditorTask:

    1. On initial load of the page, attributes for the “Tentative Assessed Parcels”, “Address Points” and “Water Bodies” layers are filtered for display and applied to the EditorTask.
    2. A custom CreateFeaturePanel is added to the Editor. It contains a custom tool that references the prepackaged CreateFeature EditorToolServerAction.
    3. A custom clip Editor tool is added to the existing GeometryToolbar1 in the EditExistingFeaturePanel.
    4. A custom Editor toolbar and custom Editor command is added to the EditExistingFeaturePanel.
    5. On pre attribute update, if a field named “UPDATEDBY” exists in the active edit layer and an authenticated user has been defined, add the username as a field value.
    6. On post attribute update, if update was not successful, return the exception message in an alert box.
    7. On pre command execute, cancel actions that delete features in the “Address Points” layer.

How to set up the sample

This section explains how to set up the sample after you have downloaded the two projects mentioned above. Before you begin, unzip the Common_CustomEditorTask_<language> zip file into a folder accessible from IIS (e.g. c:inetpubwwwroot).

Set up access to the geodatabase

You must have access to Microsoft SQL Server Express which has been configured for use with ArcSDE Workgroup geodatabases to use the data packaged with the sample. If you use your own data, you will need to change some portions of the sample code to function.

  1. Assuming you have access to SQL Server Express configured for use with ArcSDE Workgroup geodatabases, open ArcCatalog; under Database Servers click Add Database Server and connect to SQL Server Express.
  2. Right-click on the SQL Server Express instance and select Permissions. Add the ArcGIS Server container account.
  3. Right-click the SQL Server Express instance and select Attach. Navigate to the EditParcels.mdf included with the sample (e.g. c:inetpubwwwrootCommon_ CustomEditorTask _CSharpdataEditParcels.mdf). The EditParcels geodatabase should be added to the geodatabase list for the SQL Server Express instance in ArcCatalog.
  4. Right-click on the EditParcels geodatabase and select Administration>Permissions. Grant the ArcGIS Server container account readwrite privileges.

Configure the map document and create the map service

  1. Open the EditParcelsDemo.mxd in ArcMap. Note that the data source for every layer is invalid, thus a red exclamation point is displayed next to each layer name. Click (single left mouse button click) on the red exclamation point next to the “Address Points” layer to display the Set Data Source dialog.

    Setting the data source

  2. Navigate to the SQL Server Express instance on which the EditParcels geodatabase is available. Select the “EditParcels.DBO.AddressPoints” feature class and select OK. Data sources for all layers in the map document should be repaired. Save the map document. ArcMap should appear as follows.

    Map document

  3. Open ArcCatalog and add a new map service with the following properties:

    Name: EditParcelsDemo
    Map document: <path to EditParcelsDemo.mxd>
    Pooling: Not Pooled, Min instances: 0, Max instances 6

    When finished, start the service.

Configure the EditorTask projects

  1. Open the IIS Manager from Control Panel > Administrative Tools > Internet Information Services (IIS) Manager or Internet Information Services
  2. In the console tree view on the left, navigate to Local Computer > Web Sites > Default Web Site.
  3. Open the Common_ CustomEditorTask _<language> folder, right-click the CustomEditorTaskWebApp_<language> folder and click Properties.
  4. On the Directory tab, click the Create button in the Application Settings section of this panel. Click OK to dismiss the Properties dialog.
  5. Launch Microsoft Visual Studio 2005 and open the Common_ CustomEditorTask _<language> solution located where you unzipped the file in step 1. (e.g. c:inetpubwwwrootCommon_ CustomEditorTask _CSharpCommon_CustomEditorTask _CSharp.sln).
  6. In the Solution Explorer, right-click the CustomEditorTaskWebApp _<language> project and select ‘Set as StartUp Project’. Also, right-click CustomEditorTaskPage.aspx and select ‘Set As Start Page’.
  7. If necessary, set an impersonation identity for the Web application. Right-click on the Web project and select “Add ArcGIS Identity”. Enter the credentials of a user account which has been added to the agsadmin or agsusers group on the SOM (server object manager) where the EditParcelsDemo map service is running.
  8. Open the CustomEditorTaskPage.aspx in design view and define the connection properties for the single ArcGIS Server Local map resource item in the MapResourceManager.
  9. Also in design-view, set CustomEditorTask1 control properties to define the map and resource, editable layers (select all) and editable versions (select all).
  10. Open the StandardEditorTaskPage.aspx and modify the MapResourceManager and EditorTask1 using the same properties defined in the CustomEditorTaskPage.aspx.
  11. Build the solution. View both Web pages in a browser and use the EditorTask at runtime. The following screenshot shows the CustomEditorTaskPage.aspx at runtime:

    Sample Web application

Posted in Services | Tagged , , , , | 4 Comments