It is not too late to still participate – if you have not already requested to participate and are an existing Dekho client, then please email in quick.

Any issues you encounter, please fire these through to support and let them know you are running the Beta version.  Our clients outside of Australia, should also fire these requests direct to Esri Australia as well.

We anticipate sending you a download link for the Beta sometime next week.  This email will also cover what’s new in version 4.  We also anticipate that the Beta period will last for around 6 weeks.

Remember to only use the Beta on your test or development environments.

On a previous post, I did a video on how you can setup your Layout MXD to sync multiple data frames to the main data frame, so that you can display a variety of basemaps in separate data frames, all in the one printout.

I also did a post on how you can append a separate page into your one Dekho export, dedicated for a static legend.

But what happens if you wanted to click Print from Dekho once, but have a multi-page PDF, showing your area of interest with multiple basemaps on separate pages?

Our friends over at Eagle have been tweaking the ArcPy sample to do just this, for Dunedin City Council.

They are also taking advantage of fetching the data locally (avoiding any loss in quality by cutting out going via a map service) which improves print speed and output quality.

They have kindly shared the modified arcpy script, and this can be seen here (bulk of the tweaking is around lines 166 -208).

Setup:

As always, excellent work Eagle!  Would love to see how others are using ArcPy with Dekho…

Workaround:

Override the transmission compression in the Configuration MXD to a format that supports transparency.

What is Transmission Compression?

The default for an Image Service is LZ77, but this can be altered when creating your image service.  The primary benefit for this setting is so that you can use high compression formats such as JPG, which does sacrifice quality (as its a lossy format) and transparency, but then you have the benefit of sending small transmission packets to your clients, which avoids over-saturating your network and long wait times at the client end.

For more info, check the web-help and also I recommend watching this video on working with image services.

Making use of Landsat Image Services in you Dekho Maps

Whilst we are on the subject of Image Services, it is worth pointing out that the entire Landsat image services collection is available through ArcGIS Online at no cost.  I have a personal fascination in multi-spectral imagery and what you can visualise by allocating bands from the EM spectrum to good old RGB values.

Take a look and perhaps some of these services would be useful for your Dekho maps, particularly if any have a focus on land-use change or agriculture.

[Show as slideshow]

Attachments are an additional table to the primary GIS table but contains items such as documents, images and spreadsheets that are linked to one record in the feature-class.

So how can you view these attachments back in Dekho?  

In my example, I have attached some dummy photos to a petrol stations feature class.  I have then published this to a map service. To access an attachment tied to one of the petrol station features, I can hit it with this URL:

http://lap-7bjs52s/ArcGIS/rest/services/Demos/PetrolStations_Attachments/MapServer/0/101/attachments/3

Note in my example:

• My feature-class is called mds.DBO.PetrolStations (sitting in SQL Server)
• The new attachments table is called mds.DBO.Petrolstations__ATTACH (note the double _)
• The feature record OBJECT ID is 101
• The Attachment OBJECTID  is 3

The goal of Dekho is to form this URL string to use within either a Feature or Layer Info Query.

This post covers simple steps to fine-tune your system memory according to your application requirement, prior to deciding on any infrastructure changes that would be considered.

OutOfMemoryError

JVM throws this error when there is no space in memory for JVM to continue working. This happens mostly while you try to create more objects when there is no space in the heap to allocate as needed.

There are two main causes for this error.

1.  Java heap space limitation.
2.  Java perm gen limitation

Java heap limitation

This is the most commonly known fact related to the out-of-memory issue. You can tweak heap space settings using –Xmx (Maximum heap size) and –Xms (Initial heap size) parameters. In general, if you have more memory the less frequent it needs to be garbage collected. So you could expect applications to run faster when there is more memory available. But from GC’s perspective it will have to work on a larger memory than usual. It’s just like for a floor cleaner you have a bigger floor to clean than he usually does. This in turn can decrease overall performance of your application so you should tweak these settings consciously.

Example :
    -Xmx1536m
    -Xms1024m

Java Permanent Generation limitation

This is where JVM store meta data information about classes, methods (on Eden heap and Tenured heap) and other java primitives. By default this value is set to 64m. Most of the time it’s not sufficient for many applications. So it’s really important to change this setting and provide some space for perm gen to work on. Unlike xmx and xms, you have to use “=” to define this setting. Also you can use additional JVM flags “-XX:+CMSClassUnloadingEnabled” and “-XX:+CMSPermGenSweepingEnabled”. This will enforce sweeping through the permanent generation to release unused references to some extent.

Example :
    -XX:PermSize=64M
    -XX:MaxPermSize=256m
    -XX:+CMSPermGenSweepingEnabled
    -XX:+CMSClassUnloadingEnabled

Generally many Application Admins are aware of heap space settings. Yet there are many instances where perm gen settings have gone unnoticed. It’s really important to fine-tune your application for permanent generation heap as it could be a good reason for your out-of-memory errors. You can find out more information on Java Heap and profiling information here.

This got me thinking.  Modern browsers (IE9+) that support HTML5 Geolocation API, can attempt to determine where you are located.  This post is a good summary of how it does it, but you do not have to have a GPS-enabled device.  It can make estimates on ip addresses, cell phone network towers, etc.

So first off, test if your browser can locate you here.

With Flash/Flex, geolocation is restricted to Adobe Air.
However, we can still take advantage of HTML5 goodness from Dekho.

The tool:

• Checks if your browser supports the HTML5 Geolocation API (via a JavaScript function)
• Attempts to determine your location and passes lat/longs back to Dekho.
• Puts a point on the map (bouncing off geometry service to project if necessary)

Ok. So if you are sitting at your desk (like every other work day) then yes = there is little point to this tool.
However, if your out in the field then this tool could be very useful (especially if your lost).

On a more serious note, geolocation is impressive stuff.  Take a step back and have a bigger think about how you could use that information for perhaps a more elaborate custom tool.

• Combine this with the street view tool to show street view at point.
• There is a nice Esri JavaScript API sample that tracks your current location dynamically in a graphics layer.
• You could get the location and pass it into a geoprocessing service as an input parameter.
• You could use it to create a point in a feature service.
• You could combine it with routing to give the best route back to base from current location.

Setup:

• Download the tool from the downloads gallery.
• Copy the SWF and icon to the Apache ROOT folder  e.g. ..ROOT\DekhoTools\geolocation\
• Add the tool via Dekho Admin.

• Make a copy of Dekho.jsp file and then edit original.  This file is located under the Dekho folder.  A modified dekho.jsp file is included in download, but be careful to not overwrite any other customisations you may have in their.

From their you should be able to call the tool from within your Dekho maps.

Please use comments for any casual comments or Dekho Answers for more specific issues on using the tool.

For those that know me, I am a huge fan of Stack Exchange – I highly recommend checking out the GIS site.

We will dive in and have a look at fixing things up this week.

If you need assistance before that, please fire it through to support, or if its not support-related, hit us up direct.

Apologies for the inconvenience.

In Part 1 we covered how to install Jenkins and to get it ready to build Flex and .Net projects (without the need for Visual Studio or Flex Builder).

There was a reference to installing Apache Ant which you may have wondered, what is it?

Apache Ant is the tool that is going to perform the build automation for our Flex project.   Jenkins is the management of the build.

In Part 2 we will cover building of a Google Street View Dekho Flex tool.  Before we use Jenkins to manage the build process, we will build the Flex tool from the command line.

The Flex SDK

The Flex SDK provides the Flex libraries and also comes with the mxml and actionscript compiler, and Ant library to support building our Dekho tool.   While I have put the latest 4.5 SDK into my Flash Builder folder, Flash Builder is not required.

The \bin folder has mxmlc.exe and the \ant\lib folder has flexTasks.jar

Building Flex SWF with Apache Ant

In our Google Street View tool working folder lets create two new files that will be used by Apache Ant.  The two files should be checked into your source code repository so the build server will pick them up, as well as tracking changes to the build configuration.

1. build.properties – Build properties specific to this project.
2. build.xml – Generic build file for our custom Dekho Flex tools.  You should not need to make further changes to this file.

build.properties

Update this file with the paths to the required tools (and version), and the name of the application / source mxml file to build.    This StreetView sample tool is an older example being built with Flex SDK 3.5.0


######################################
## Project information
######################################
application.name=StreetView

# Where flex is installed:
FLEX_HOME=C:/Program Files/Adobe/Adobe Flash Builder 4 Plug-in/sdks/3.5.0
LOCALE=en_US
ENCODING=UTF-8

######################################
## tools
######################################

### FlexTask
FLEX.TASK.DIR=${FLEX_HOME}/ant/lib/flexTasks.jar

# Browsers
firefox=C:/Program Files/Mozilla Firefox/firefox.exe
ie=C:/Program Files/Internet Explorer/iexplore.exe

######################################
## Properties
######################################
src.dir=src
bin.dir=bin-release
lib.dir=libs
wrapper.dir=html-template
html.file=${bin.dir}/${application.name}.html

main.class = ${src.dir}/${application.name}.mxml
swf.export = ${bin.dir}/${application.name}.swf

# ASSETS DIR
assets.dir=${src.dir}/assets/

 build.xml

This build.xml file has four target sections which run in the following order;

1. clean – deletes the old build files
2. init – some info about the build
3. compile – perform the build
4. wrapper – copies the html-template folder to the release folder and uses index.template.html to create StreetView.html


<?xml version="1.0" encoding="utf-8"?>
<project name="Dekho Custom Tool" basedir="." default="masterbuild">

<!– Load Environment specific properties from properties file –>
<property file=”build.properties” />

<!– Load the flex tasks for compiling the actionScript code and running flexUnit –>
<taskdef resource=”flexTasks.tasks” classpath=”${FLEX.TASK.DIR}” />

<target name=”init” description=”Initializes the build”>
<tstamp/>
<echo message=”=============================================”/>
<echo message=”${application.name} [${TODAY}]“/>
<echo message=”OS : ${os.name}” />
<echo message=”==============================================”/>
</target>

<!– Compile Main application –>
<target name=”compile” depends=”init” description=”Compiles the mxml/as source files”>
<mxmlc
file=”${main.class}”
output=”${swf.export}”
actionscript-file-encoding=”${ENCODING}”
keep-generated-actionscript=”false”
incremental=”false”
locale=”${LOCALE}”
compiler.as3=”true”
>
<load-config filename=”${FLEX_HOME}/frameworks/flex-config.xml”/>
<compiler.source-path path-element=”${FLEX_HOME}/frameworks”/>
<compiler.debug>false</compiler.debug>
<compiler.source-path path-element=”${src.dir}”/>
<compiler.include-libraries dir=”${basedir}” append=”true”>
<include name=”${FLEX_HOME}/lib” />
</compiler.include-libraries>
<!– List of SWC files or directories that contain SWC files. These will be link-merged –>
<compiler.library-path dir=”${lib.dir}” append=”true”>
<include name=”*.swc” />
</compiler.library-path>

</mxmlc>
</target>
<!– Clean output dirs –>
<target name=”clean” description=”clean all generated files”>
<delete includeemptydirs=”true” verbose=”true”>
<fileset dir=”${bin.dir}” includes=”**/*” />
</delete>
</target>
<!– Create HTML wrapper –>
<target name=”wrapper” depends=”compile” description=”Creates the HTML wrapper”>
<!– Copy the html-wrapper dir except the index.template.html –>
<copy todir=”${bin.dir}”>
<fileset dir=”${wrapper.dir}”>
<exclude name=”**/index.template.html” />
</fileset>
</copy>
<!– Copy and rename the index.template.html –>
<copy file=”${wrapper.dir}/index.template.html”
tofile=”${html.file}” />

<!– Replace placeholders in the html with our variables –>
<!–Check the flex version_major, version_minor, version_revision–>
<replaceregexp
file=”${html.file}”
flags=”gs”
match=”\$\{width\}”
replace=”100%”/>
<replaceregexp
file=”${html.file}”
flags=”gs”
match=”\$\{height\}”
replace=”100%”/>
<replaceregexp
file=”${html.file}”
flags=”gs”
match=”\$\{title\}”
replace=”{project.name}”
encoding=”utf-8″/>
<replaceregexp
file=”${html.file}”
flags=”gs”
match=”\$\{version_major\}”
replace=”9″/>
<replaceregexp
file=”${html.file}”
flags=”gs”
match=”\$\{version_minor\}”
replace=”0″/>
<replaceregexp
file=”${html.file}”
flags=”gs”
match=”\$\{version_revision\}”
replace=”0″/>
<replaceregexp
file=”${html.file}”
flags=”gs”
match=”\$\{application\}”
replace=”${application.name}”/>
<replaceregexp
file=”${html.file}”
flags=”gs”
match=”\$\{bgcolor\}”
replace=”#FFFFFF”/>
<replaceregexp
file=”${html.file}”
flags=”gs”
match=”\$\{swf\}”
replace=”${application.name}”/>
</target>

<!– Run all, default –>
<target name=”masterbuild”
depends=”clean, compile, wrapper”
description=”Complete build in efficient sequence”/>

</project>

 Building the Dekho Flex tool

Open a command prompt in the StreetView tool folder and run the following command line
ant masterbuild

If the build is successful, commit the build.xml and build.properties to source control.

Jenkins Build Job

Now we have successfully created the Flex SWF file, let us create the Jenkins job to manage it on the build server.

1. Open the Jenkins dashboard.   http://my_build_server:8080/jenkins/
2. Click on New Job and give it a name
3. Enter the source code repository details.
4. Select Build periodically, and/or Poll SCM.   You will most likely want to have a nightly build, and Poll SCM for changes every few minutes for continuous integration.
5. Click Add build step button, and select Invoke Ant
6. Set the Ant target to the target name in build.xml to run.  In our case masterbuild
7. Further build steps can be added via different plugins.  For example, running units test, building install program, and copy the release to a file server.
8. Set the email notification addresses.
9. Save the job.
10. To test the build process, force the job to run now by clicking on the green arrow next to the job.
11. View the build console output
    

• What version of SDK/libraries/framework and settings did person X build the software with?
• Did person X actually commit/add the source code to source control before it was released to test?
• Person X is sick or unavailable, I need a new build so I can test the latest changes.  Have to wait?
• Development team is constantly being interrupted, and re-building install programs is just one more interruption
• There are actually automated unit tests for the code, but did they get run before the test release?
• The last change was a few years ago, and no one here knows how to build it?  or no one has a license to install the tool(s) to create it?

If any of the above are true, then it is most likely there is no central point of truth for your software release.

An automated build server solve the above issues;

• The build server is a controlled deployment of SDK’s, libraries and frameworks required for the solutions.  The configuration of the build sequence is managed by the automated build tool.
• Source code has to be commit to source control, before the build server can fetch it from source control.  It does this either periodically or if it detects a change.  The build will fail if you partially committed the code, and the team will be automatically emailed.
• Testers can go to the build server or file share location to get the latest build with out interrupting the development team.  However it is a responsibility of the development team that the build server is working.
• Unit tests can get added to the automated build sequence.  If they fail, the team gets emailed.
• The automated build sequence remains after others have gone.   Additionally .Net and Flex solutions get built without a requirement of a license for Microsoft Visual Studio, or Adobe Flash Builder.

There are several automated build tools available that manage the process of building, and possibly deploying, a new software release.  This blog will discuss the install of the Jenkins (aka Hudson) automated build tool.  All open source.   Part 2 will cover building a Dekho custom tool, Google Street View.

A quick overview of the Jenkins dashboard.  The centre of the screen shows the jobs that have been created and their current status.  Clicking on one of the job will take you to the details of the job.

Pre-requisites

• Windows virtual machine (XP, Server 2003, Server 2008, Windows 7,…)
• Source Code Repository Client. eg Tortoise Subversion Client http://tortoisesvn.net/downloads.html
• Java Development Kit (JDK)
• Tomcat web server (Currently v7)
• Jenkins http://jenkins-ci.org/
• Apache Ant http://ant.apache.org/
• Adobe Flex SDK http://opensource.adobe.com/wiki/display/flexsdk/Download+Flex+4.5
• .Net 3.5 and 4.0 if using MSBuild to build .Net projects
• ArcObjects .Net SDK if your solutions includes web services/ArcMap addins that require ArcObjects

Install

1. Install Source Code Repository Client.   In our case this is TortoiseSVN.
2. Install the JDK.
3. Create the JAVA_HOME environment variable, point to the JDK path location.
4. Install .Net 3.5, 4.0 if you are going to be building .Net solutions.  This includes MSBUILD
5. Install ArcObjects SDK version required and service pack.
6. Install the Flex SDK(s).  Currently v4.5
7. Install Tomcat.  Use port 8080
8. Change Tomcat windows service to automatic start
9. Copy the Jenkins.war file to the Tomcat web folder.   Tomcat should extract it and create a Jenkins folder
10. Jenkins will create a working folder in C:\.Jenkins.   If you want to move this, stop Tomcat first then move the folder.
11. Create a JENKINS_HOME environment variable, point to the working folder.
12. Install the Apache Ant files to C:\Program Files\Apache Software Foundation\Ant
13. Create a ANT_HOME environment variable, point to the path location.
14. Add to the PATH environment variable %ANT_HOME%\bin.
15. Reboot so the environment variable changes are loaded.

Configure

1.  Open the URL http://localhost:8080/jenkins/
2. Click on the Manage Jenkins link
   
3. Click on Manage Plugins
4. Click on Available Plugins
5. Select Ant, and MSBuild plugins, then select Install.
   If your server doesn’t have internet access, do it manually.
   https://wiki.jenkins-ci.org/display/JENKINS/Plugins#Plugins-Byhand
   
6. Go back to Manage Jenkins, and select Configure
7. Add a MS-Build install for .Net 3.5 and .Net 4.0.  See screen shot.  This give you the choice of which .Net compiler to invoke when building your .Net solution.
8. Setup the Email server details for notifications.
9. Save the configuration changes

In Part 2, I will cover setting up Jenkins Job for a custom Dekho Flex tool.

As a result, to a newcomer, they may need some initial guidance on how to use Dekho to get the information they need.

I know a lot of our clients give internal training on Dekho to their users.  However, how is this going to work with a public facing Dekho or if a casual internal user needs to hop on, but does not require full training?

This was very easy to achieve, with a little help from a plugin for JQuery.

Required changes:

1. Make a backup of your dekho.jsp file (under …Tomcat\webapps\Dekho)
2. Download latest version of noty from their Github page.
3. Extract the zip to a folder called custom underneath the Dekho folder in webapps.
4. Optional step – download a local copy of JQuery and also place under custom folder.
5. Open dekho.jsp in a text editor.  Make the changes highlighted below – this references JQuery and the Noty plugin, and also adds in some additional CSS for the font in the alert bar.

Then include the below function within the functions section further down in the file:

My entire dekho.jsp can be seen here if you want to copy and paste that function.

The noty options can be tweaked on the noty site.

This function could be tweaked to perhaps show the alertbar for the first few times, or perhaps for a few days.  You could even get fancy and make it a sticky alertbar, move it to the side, and only stop showing it when the user clicks the exit sign.

Another thing worth mentioning – you can edit the built in help with a WYSIWYG HTML editor  to include additional pages.

I personally recommend to clients, to tweak the help tool to point to ‘Using Dekho for the 1st Time‘  and editing ..\Tomcat\webapps\Dekho\help\Documents\usingdekhoforthefirsttime.htm to embed some videos (I recommend screencast.com) showing your users how to achieve specific workflows in Dekho.  This will help your users understand how and what you can do with Dekho, specifically to your business.

Just remember – if you make modifications to files beneath the Dekho folder, to back these up.  When you upgrade, the Dekho folder is scrapped and a new one deployed.

http://machine/arcgis/services

but would not publish from:

http://machine/arcgis1/services

(note the additional ‘1’ after arcgis):

By default Dekho expects the following ArcGIS map service URL pattern: http://machine/arcgis/services, however it is possible specify additional configurations if required. A list of ArcGIS url patterns is fed into Dekho through a file called ‘beans.xml’, and this can be modified to accommodate a non standard URL.

For example, to add the URL ‘/arcgis1/services’ to the list, the steps are as follows:

1.       Open <tomcat_server>\webapps\Dekho\WEB-INF\classes\beans.xml file in a text editor.

2.       Search for following text:

 <!– Start.. RestURL static initialization –>
<bean id=”restURLPattenInit”
class=”au.com.esriau.dekho.config.RestURL”>
<constructor-arg>
<list>
<value>(/[Aa]rc[Gg][Ii][Ss])(/[rR][eE][sS][tT]/[Ss][eE][rR][vV][iI][cC][eE][sS]/)</value>
<value>(/[Mm][Dd][Ss])(/[rR][eE][sS][tT]/[Ss][eE][rR][vV][iI][cC][eE][sS]/)</value>
</list>
</constructor-arg> <constructor-arg>
<list>
<value>(/[Aa]rc[Gg][Ii][Ss])(/[Ss][eE][rR][vV][iI][cC][eE][sS]/)</value>
<value>(/[Mm][Dd][Ss])(/[Ss][eE][rR][vV][iI][cC][eE][sS]/)</value>
</list>
</constructor-arg> </bean> <!– End.. RestURL static initialization –>

3       Edit it to equal:

<!– Start.. RestURL static initialization –>
<bean id=”restURLPattenInit”
class=”au.com.esriau.dekho.config.RestURL”>
<constructor-arg>
<list>
<value>(/[Aa]rc[Gg][Ii][Ss])(/[rR][eE][sS][tT]/[Ss][eE][rR][vV][iI][cC][eE][sS]/)</value>
<value>(/[Aa]rc[Gg][Ii][Ss]1)(/[rR][eE][sS][tT]/[Ss][eE][rR][vV][iI][cC][eE][sS]/)</value>
<value>(/[Mm][Dd][Ss])(/[rR][eE][sS][tT]/[Ss][eE][rR][vV][iI][cC][eE][sS]/)</value>
</list>
</constructor-arg> <constructor-arg>
<list>
<value>(/[Aa]rc[Gg][Ii][Ss])(/[Ss][eE][rR][vV][iI][cC][eE][sS]/)</value>
<value>(/[Aa]rc[Gg][Ii][Ss]1)(/[Ss][eE][rR][vV][iI][cC][eE][sS]/)</value>
<value>(/[Mm][Dd][Ss])(/[Ss][eE][rR][vV][iI][cC][eE][sS]/)</value>
</list>
</constructor-arg> </bean> <!– End.. RestURL static initialization –>

We have added in two new lines (essentially: ‘ArcGIS1/REST/SERVICES/’ and ‘ArcGIS1/SERVICES/’) using the required bracketed format.

4          Now restart the application server and you should be good to go.

• Open up your configuration mxd and add in a vector layer (an SDE feature layer)
• For the layer go into Properties=>Display and under Display Expression tick the option to ‘Show MapTips using the display expression’
• Select the field you want to use as the basis of your Map Tip from the drop down (and create an expression if desired)
• Click OK and test the Map Tips by hovering your cursor over the features in your vector layer
• Save the configuration mxd to your config mxd directory and publish it to Dekho
• Open your Dekho Map and you are good to go

Should point out that as of v3.3 we are retiring ‘vector layers’ in your Configuration MXD, and replacing the functionality they provided with the Feature Service.

Surface Profile Tool

Draw a polyline across your map, and it will bounce off the Esri sample service to return an elevation profile along that line.

Line of Sight Tool (Viewshed analysis)

Set a view distance & click the map to bounce off the Esri Sample service to calculate the viewshed from that location.

The code is included with both downloads and you can set up similar services and re-tweak the tools to point to your own.

Please bare in mind that custom tools are not supported but please direct issues/feedback about them to Dekho Answers.

Pending the popularity of tools, we will try to keep them up to date against newer versions of Dekho.

This code originated from Mansour Raad, a Senior Software Architect at Esri.

We  have also updated the Dual Maps tool

• Fixed a bug where it could not be dragged to far right hand side of Dekho
• Added options to include Google Traffic and photo layers.
• Ability to search embedded google map.

The dedicated street view tool has the advantage in that as you pan around within the streetview, it updates the location and viewing angle to the Dekho map.

However, the Dual Maps tool does allow you to switch to full screen for a better look at whats happening on the ground.

For future versions we will try and mash the missing functionality into both tools.

Don’t be afraid of custom tools – give them both a whirl!

For this scenario, the easiest approach would be to make use of an IFrame.

1. Create a new page on your website.
2. Within the <body> tag, place the following:
   <iframe height=”90%” width=”90%” src=”http://<InsertHostName>:8080/Dekho/”</iframe>

Should you use an IFrame?  For the above scenario, I do not think there are any drawbacks to using an IFrame to embed Dekho within your main website.  The IFrame is still about in HTML5, and it is a very easy way to embed Dekho into your main website.

The alternative approach is to either edit the Dekho.jsp page, to include a header/footer, or better still – to separate our the required Javascript from the Dekho.jsp and reference it from your main web page, and make use of swfObject to embed Dekho directly into your code.

Remember you can also tweak if the sidebar is expanded on initial load with the use of start.tab

Esri Australia are pleased to announce the launch of our first Dev Meet Up group, which is to be established in Melbourne.

This Dev Meet Up is a social gathering for developers to discuss geospatial technologies, complementary third-party tools, and development platforms (e.g., Silverlight, Java, Flex, JavaScript) that are supported by Esri. Presentations run the gamut of our community: from Web development to mobile location development for iOS, Android and Windows Phone 7 to automating tasks with Python. Developers of all levels of expertise are welcome, from seasoned GIS professionals to those new to geospatial development. At these meetups, you can:

If you want to follow the Apache Flex project and get involved, check this page:http://incubator.apache.org/flex/

This not only improves the quality (as the map services ‘rasterise’ the raw data), but also dramatically speeds up the process.

For a 600DPI print at A1 using the standard ArcPy print sample for Dekho (via map services) = 1 minute

Same again, but the ArcPy pointing to the data in a local File-GDB = 20s

Please see this screen-cast on how to make the necessary changes:

Another plus point, is that the output PDFs will also allow the end-user to turn layers on/off via the PDF.  You can also tweak the script to allow users to identify attributes and get coordinates from the PDFs.

The code snippet you need to change within the existing ArcPy Sample for Dekho printing is this.  Watch the video for details on the changes.

# --------------------------------------------------------------------------------
# Create a temporary print layout based on the map document given for printing,
# the layout mxd and the visible layers selected for printing.
# --------------------------------------------------------------------------------
def createPrintMap(sourcMxdPath, layoutMxdPath, visibleLayers):
 arcpy.AddMessage("Creating print layout")
 arcpy.AddMessage("Jerome Test")

 # Load source MXD
 #sourceMxd = arcpy.mapping.MapDocument(sourcMxdPath)
 #sourceDf = arcpy.mapping.ListDataFrames(sourceMxd, "Layers")[0]

 # Load print layout MXD
 layoutMxd = arcpy.mapping.MapDocument(layoutMxdPath)
 layoutDf = arcpy.mapping.ListDataFrames(layoutMxd, "Layers")[0]

 lyrCount = 1
 for lyr in arcpy.mapping.ListLayers(layoutMxd, "", layoutDf):
 try:
 visibleLayers.index(repr(lyrCount))
 # Layer is in the visible layers list.
 lyr.visible = True
 except Exception:
 lyr.visible = False
 pass
 #arcpy.mapping.AddLayer(layoutDf, lyr, "BOTTOM") # values could be AUTO_ARRANGE, BOTTOM, TOP
 lyrCount += 1

 # Get random filename to save the temporay print file.
 printTemplate = getTempFile("DekhoPrint_","mxd")

 # Save the template file in the scratch workspace.
 layoutMxd.saveACopy(printTemplate)

 return printTemplate

1)       In your configuration .mxd, right click on one (or more) of your service layers (or groups of layers)

2)      Go into ‘Properties’ and under the ‘General’ tab write one or more tags into the ‘Description’ text box, for example: LEGEND_VISIBLE=FALSE; IDENTIFY=FALSE;

3)      Save the mxd and then publish it as a map through Dekho Admin.

4)       When you then view the map in Dekho, in this example your layer will display, but the legend will not be visible in the table of contents. Additionally the layer will be hidden from the Info tool.

NB: Make sure you include the ; at the end of each tag you use.

There are numerous tags, with descriptions spread across the Dekho Web Help, Dekho Blogs and Dekho TV. However, we have now compiled them into a single resource, complete with links to the relevant web pages. At present this exists as PDF document you can download (and print out for your wall!), but in the future it will make it into the main help. I hope this is helpful to you and please comment if you have any improvements.

Here is the Link to download the Download Layer Description Tag PDF