Tutorial: Impresión/Exportación avanzadas de mapas web mediante arcpy.mapping

Complejidad: AvanzadoRequisitos de datos: Instalado con el software

La siguiente ilustración muestra un ejemplo de aplicación SIG Web que usa ArcGIS API for JavaScript que va a crear. En la aplicación web, el usuario final podrá:

• Desplazarse hasta un área de interés.
• Seleccionar una plantilla de diseño presentada.
• Seleccionar un formato de salida.
• Elegir entre exportar o no información de georreferenciación a un archivo PDF de salida transmitiendo un parámetro adicional desde la aplicación web hasta la tarea Imprimir. (A continuación figura más información.)
• Controlar qué subcapas del servicio están activadas y desactivadas en el mapa.
• Controlar qué subcapas del servicio están activadas y desactivadas en la leyenda del archivo de salida. (Es decir, una capa puede estar activada en el mapa y desactivada en la leyenda.)
• Exportar el mapa a un formato apto para la impresión con una salida de vectores de capas de servicio.

A continuación figura un ejemplo de salida en PDF. Tenga en cuenta que las capas que se hayan desactivado en la Tabla de contenido y en la Leyenda, en la aplicación web, se reflejarán en la salida.

El código detrás del botón Exportar mapa utiliza la tarea Imprimir de ArcGIS API for JavaScript , disponible a partir de ArcGIS 10.1 for Desktop y ArcGIS for Server 10.1. En este tutorial también se enseñará a transmitir parámetros extra a la tarea Imprimir; por ejemplo, si exportar o no información de georreferenciación al archivo PDF de salida. La posibilidad de transmitir parámetros adicionales a la tarea Imprimir es de utilidad porque permite capturar cualquier número de parámetros adicionales desde la aplicación web. También creará una secuencia de comandos de Python que se publicará como servicio de geoprocesamiento que usará la tarea Imprimir. La secuencia de comandos de Python utiliza la función ConvertWebMapToMapDocument del módulo arcpy.mapping, que insertará el estado completo del mapa web en un documento de mapa de plantilla presentado. Presentará varias plantillas entre las que podrá elegir el usuario. Cada plantilla contiene equivalentes en vectores de todas las capas posibles en el servicio de mapas. Las plantillas presentadas también pueden contener otros elementos, como una leyenda, texto dinámico, etc. El módulo arcpy.mapping también ofrece funciones para identificar capas de servicio y cambiarlas por capas que apunten a datos locales, así como para exportar a distintos formatos; por ejemplo, PDF.

Para completar este tutorial, debe estar familiarizado con el módulo arcpy.mapping, ArcGIS API for JavaScript, ArcGIS for Desktop y ArcGIS for Server. También debe familiarizarse con la impresión en los temas de ayuda de la aplicación Web:

Imprimir en aplicaciones webOpciones avanzadas para imprimir mapas web

En este tutorial se utilizan las carpetas MapTemplates y TemplateData del directorio de instalación de ArcGIS for Desktop, que suele estar en C:\Archivos de programa (x86)\ArcGIS\Desktop10.3. En este tutorial se da por supuesto que las plantillas de mapa y los datos de plantilla están presentes y no se han modificado. Si no es el caso, tal vez deba reinstalar ArcGIS for Desktop.

Copiar los datos del tutorial

Copiará algunas de las plantillas de mapa del directorio de instalación de ArcGIS for Desktop a una nueva carpeta. Estas plantillas se acabarán utilizando como plantillas de mapa presentadas en la aplicación web.

Antes de hacerlo, debe asegurarse de que haya una estructura de carpetas en la que ArcGIS for Server pueda ver los documentos de mapa de plantilla y los datos que se usarán en la aplicación web. En este tutorial se da por supuesto que tiene una carpeta registrada en ArcGIS for Server. Para obtener más información sobre el registro de datos en ArcGIS for Server, consulte:

Hacer accesibles los datos para ArcGIS ServerAcerca de cómo registrar los datos con ArcGIS ServerRegistrar los datos con ArcGIS Server utilizando ArcGIS for Desktop

Sugerencia:

Cuando utilice documentos de mapa de plantilla en la función ConvertWebMapToMapDocument, lo más recomendable es usar datos que estén registrados en ArcGIS for Server. Si opta por no usar datos registrados, los documentos de mapa de plantilla y los datos se empaquetarán y copiarán en el servidor. Durante el empaquetamiento, los datos pueden moverse y asignarse con rutas relativas hasta una estructura de carpetas que ConvertWebMapToMapDocument no puede resolver. Para obtener más información, consulte el tema de ayuda ConvertWebMapToMapDocument.

1. Abra una nueva sesión vacía de ArcMap.
2. En la ventana Catálogo, desplácese hasta la carpeta registrada. Cree una nueva carpeta en la carpeta registrada llamada USA.
3. En la ventana Catálogo, vaya hasta la carpeta MapTemplates del directorio de instalación de ArcGIS for Desktop. Suele encontrarse en C:\Archivos de programa (x86)\ArcGIS\Desktop10.3\MapTemplates. Siga desplazándose hasta la carpeta Traditional Layouts\USA.
4. En la ventana Catálogo, copie y pegue los siguientes archivos en la carpeta USA que creó en el paso anterior: CentralUSA.mxd, ConterminousUSA.mxd, NortheasternUSA.mxd, NorthwesternUSA.mxd, SouthernUSA.mxd y SouthwesternUSA.mxd.
   
5. En la ventana Catálogo, vaya hasta la carpeta TemplateData del directorio de instalación de ArcGIS for Desktop. Suele encontrarse en C:\Archivos de programa (x86)\ArcGIS\Desktop10.3\TemplateData.
6. En la ventana Catálogo, copie y pegue TemplateData.gdb en la carpeta USA que creó en un paso anterior.
   
7. La carpeta registrada debe tener un aspecto similar al siguiente:
   

   Nota:

   En la captura de pantalla anterior, la carpeta registrada se llama MyDataStore. La carpeta registrada puede tener el nombre que desee.

Prepare los documentos de mapa que usar como plantillas en la aplicación web.

Los documentos de mapa deben prepararse para su uso como plantillas en ConvertWebMapToMapDocument.

Los documentos de mapa que están ahora en la carpeta registrada deben asignarse a TemplateData.gdb, que también está en la carpeta registrada. Esto puede hacerse a través de la interfaz de usuario de ArcMap o con una secuencia de comandos de Python. Se utilizará el segundo método.

Nota:

Si estaba creando desde cero sus propias plantillas de documento de mapa en la carpeta registrada, estos pasos no serán necesarios.

1. Abra la ventana de Python en ArcMap.
2. Copie y pegue la siguiente secuencia de comandos en la ventana de Python:

import arcpy, os
# The path to the registered folder where the template MXDs reside
folderPath = "C:/MyDataStore/USA"
# The location of TemplateData.gdb within the registered folder
newPath = "C:/MyDataStore/USA/TemplateData.gdb"
# Loop through all MXDs in the specified folder and change the layer's data source to the new path
for filename in os.listdir(folderPath):
    fullpath = os.path.join(folderPath, filename)
    if os.path.isfile(fullpath):
        basename, extension = os.path.splitext(fullpath)
        if extension.lower() == ".mxd":
            mxd = arcpy.mapping.MapDocument(fullpath)
            mxd.findAndReplaceWorkspacePaths(arcpy.mapping.ListLayers(mxd)[1].workspacePath, newPath)
            mxd.save()
print "done"

3. En la ventana de Python, cambie la variable folderPath para que sea la ruta hasta la carpeta registrada en la que residen los MXD de la plantilla. Recuerde usar barras inclinadas (/) en la ruta.
4. En la ventana de Python, cambie la variable newPath para que sea la ubicación de TemplateData.gdb en la carpeta registrada. Recuerde usar barras inclinadas (/) en la ruta.
5. La secuencia de comandos debe tener este aspecto:
   
6. Coloque el cursor a la derecha de la última línea. Pulse la tecla Intro dos veces para ejecutar la secuencia de comandos. Espere a que la secuencia de comandos se ejecute.

Los documentos de mapa ya están listos para ser utilizados como plantillas en la aplicación web.

Crear un servicio de mapa que utilizar en la aplicación web

Para poder usarse en la aplicación web, un documento de mapa debe prepararse y publicarse como servicio de mapa. Se utilizará ConterminousUSA.mxd, en la carpeta registrada, como servicio de mapa. Antes de publicarlo en el servidor, debe prepararlo para la publicación.

1. Abra ConterminousUSA.mxd en ArcMap.
2. De forma predeterminada, el mapa se abrirá en vista de diseño. Cambie a la vista de datos seleccionando Vista > Vista de datos en el menú principal de ArcMap.
3. Ahora desactivará el grupo de anotaciones de mapa en este documento de mapa. Este mapa contiene gráficos de mapa. Los gráficos de mapa aumentan la huella de memoria de un documento cargado, lo que produce una degradación del rendimiento. Debido a estos efectos secundarios, los gráficos de mapa no son compatibles con los servicios de mapas.
   1. Abra las propiedades del marco de datos Conterminous United States haciendo clic con el botón derecho en el nombre del marco de datos, en la tabla de contenido y haciendo clic en Propiedades.
   2. Haga clic en la pestaña Grupos de anotación.
   3. Desactive el grupo <Default>. La pestaña Grupos de Anotación debe tener ahora este aspecto:
      
   4. Haga clic en Aceptar en el cuadro de diálogo Propiedades del marco de datos.
4. Este mapa utiliza capas de mapa base. Las capas de mapa base no se publicarán en ArcGIS for Server. Moverá las capas fuera de la capa de mapa base desagrupando esta.
   1. Haga clic con el botón derecho en la capa de mapa base, en la tabla de contenido y haga clic en Desagrupar.

   Nota:

   Si estaba creando desde cero sus propias plantillas de documento de mapa o estaba usando plantillas existentes de documento de mapa que no contuvieran gráficos de mapa o capas de mapa base, estos pasos no serán necesarios.

   El mapa ya está listo para publicarse en el servidor. Si no está familiarizado con el proceso de publicación, revise cómo publicar un servicio.

5. Haga clic en Archivo > Compartir como > Servicio.
6. Haga clic en Publicar un servicio.
7. Haga clic en Siguiente.
8. Elija una conexión de publicación o administración con el equipo de ArcGIS for Server.
9. Haga clic en Siguiente.
10. Cree una nueva carpeta llamada USA.
11. Haga clic en Continuar.
12. En la esquina superior derecha del Editor de servicios, haga clic en Publicar.

Con esto se creará el servicio de mapa que se usará en la aplicación web.

Crear la secuencia de comandos de Python

Creará una secuencia de comandos de Python que se usará como servicio de geoprocesamiento personalizado.

La secuencia de comandos de Python en el servicio de geoprocesamiento personalizado ejecuta la función ConvertWebMapToMapDocument, que convierte un mapa Web (en formato JSON) que pretenda imprimir o exportar a un documento de mapa. A continuación, la secuencia de comandos arcpy.mapping recorre todas las capas del documento de mapa de salida, quitando todas las capas excepto las de vectores que se correspondan con las capas de servicio en el JSON del mapa web. A continuación, recorre todas las capas de la leyenda, quitando todas las leyendas excepto las capas de vectores que se correspondan con las capas de servicio en la leyenda del JSON del mapa web. La secuencia de comandos también leerá parámetros adicionales desde la tarea de impresión personalizada; en este caso, si exportar o no información de georreferenciación al archivo PDF de salida. A continuación, el documento de mapa puede exportarse al formato que elija; por ejemplo, PDF.

1. Abra cualquier IDE de Python, como IDLE (que se suministra con ArcGIS for Desktop).
2. Copie y pegue el siguiente código en una nueva secuencia de comandos de Python.

import arcpy
import os
import uuid
# The template location in the registered folder (as UNC path)
templatePath = '//MyComputerName/MyDataStore/USA'
# Input WebMap json
Web_Map_as_JSON = arcpy.GetParameterAsText(0)
# Format for output
Format = arcpy.GetParameterAsText(1)
if Format == '#' or not Format:
    Format = "PDF" 
# Input Layout template
Layout_Template = arcpy.GetParameterAsText(2)
if Layout_Template == '#' or not Layout_Template:
    Layout_Template = "NorthwesternUSA" 
    
# Extra parameter - georef_info
Georef_info = arcpy.GetParameterAsText(3)
if Georef_info == '#' or not Georef_info:
    Georef_info = "False"
# Convert Georef_info string to boolean
if Georef_info.lower() == 'false': 
    Georef_info_bol = False
elif Georef_info.lower() == 'true': 
    Georef_info_bol = True
# Get the requested map document
templateMxd = os.path.join(templatePath, Layout_Template + '.mxd')
# Convert the WebMap to a map document
result = arcpy.mapping.ConvertWebMapToMapDocument(Web_Map_as_JSON, templateMxd)
mxd = result.mapDocument
# Reference the data frame that contains the webmap
# Note: ConvertWebMapToMapDocument renames the active dataframe in the template_mxd to "Webmap"
df = arcpy.mapping.ListDataFrames(mxd, 'Webmap')[0]
# Get a list of all service layer names in the map
serviceLayersNames = [slyr.name for slyr in arcpy.mapping.ListLayers(mxd, data_frame=df) 
                      if slyr.isServiceLayer and slyr.visible and not slyr.isGroupLayer]
# Create a list of all possible vector layer names in the map that could have a 
# corresponding service layer
vectorLayersNames = [vlyr.name for vlyr in arcpy.mapping.ListLayers(mxd, data_frame=df) 
                     if not vlyr.isServiceLayer and not vlyr.isGroupLayer]
# Get a list of all vector layers that don't have a corresponding service layer
removeLayerNameList = [vlyrName for vlyrName in vectorLayersNames 
                       if vlyrName not in serviceLayersNames]
# Remove all vector layers that don't have a corresponding service layer
for lyr in arcpy.mapping.ListLayers(mxd, data_frame=df):
    if not lyr.isGroupLayer \
    and not lyr.isServiceLayer \
    and lyr.name in removeLayerNameList \
    and lyr.name in vectorLayersNames:
        arcpy.mapping.RemoveLayer(df, lyr)
                
# Reference the legend in the map document
legend = arcpy.mapping.ListLayoutElements(mxd, "LEGEND_ELEMENT")[0]
# Get a list of service layers that are on in the legend because the incoming 
# JSON can specify which service layers/sublayers are on/off in the legend
legendServiceLayerNames = [lslyr.name for lslyr in legend.listLegendItemLayers() 
                           if lslyr.isServiceLayer and not lslyr.isGroupLayer]
# Remove vector layers from the legend where the corresponding service layer 
# is also off in the legend
for lvlyr in legend.listLegendItemLayers():
    if not lvlyr.isServiceLayer \
    and lvlyr.name not in legendServiceLayerNames \
    and not lvlyr.isGroupLayer \
    and lvlyr.name in vectorLayersNames:
        legend.removeItem(lvlyr)
# Remove all service layers
# This will leave only vector layers that had corresponding service layers
for slyr in arcpy.mapping.ListLayers(mxd, data_frame=df):
    if slyr.isServiceLayer:
        arcpy.mapping.RemoveLayer(df, slyr)
        
# ConvertWebMapToMapDocument renames the active dataframe in the template_mxd to "Webmap".
# Lets rename it to something more meaningful.
df.name = Layout_Template
# Use the uuid module to generate a GUID as part of the output name
# This will ensure a unique output name
output = 'WebMap_{}.{}'.format(str(uuid.uuid1()), Format)
Output_File = os.path.join(arcpy.env.scratchFolder, output)
# Export the WebMap
if Format.lower() == 'pdf':
    arcpy.mapping.ExportToPDF(mxd, Output_File, georef_info=Georef_info_bol) 
elif Format.lower() == 'png':
    arcpy.mapping.ExportToPNG(mxd, Output_File)
# Set the output parameter to be the output file of the server job
arcpy.SetParameterAsText(4, Output_File)
# Clean up - delete the map document reference
filePath = mxd.filePath
del mxd, result
os.remove(filePath)

3. Cambie la variable templatePath para que sea la ruta UNC hasta la carpeta de la carpeta registrada que contiene los documentos de mapa de la plantilla.

Nota:

Si ArcGIS for Server, ArcGIS for Desktop y la carpeta registrada están en el mismo equipo, las rutas UNC hasta la carpeta registrada no son necesarias. En lugar de ello, pueden usarse rutas absolutas.

4. Guarde la secuencia de comandos de Python. Dé a la secuencia de comandos el nombre AdvancedHighQualityPrinting.py. Guárdelo en una carpeta llamada WebApp dentro de la carpeta registrada.

La secuencia de comandos de Python ya está lista para agregarse a una caja de herramientas.

Cree la caja de herramientas

1. En la ventana Catálogo, en ArcMap, desplácese hasta la carpeta WebApp, en la carpeta registrada.
2. Haga clic con el botón derecho en la carpeta WebApp y haga clic en Nuevo > Caja de herramientas. Dé a la caja de herramientas el nombre AdvancedHighQualityPrinting.
3. Haga clic con el botón derecho en la caja de herramientas AdvancedHighQualityPrinting y haga clic en Descripción del elemento.
4. En el cuadro de diálogo Descripción del elemento, rellene los elementos Etiquetas y Resumen con el texto que elija. Si lo desea, rellene las demás descripciones del elemento.
5. Haga clic en Guardar y salga del cuadro de diálogo Descripción del elemento.

Crear una herramienta de secuencia de comandos de Python

A continuación, agregará la secuencia de comandos AdvancedHighQualityPrinting.py a la caja de herramientas AdvancedHighQualityPrinting.

1. En la ventana Catálogo, haga clic con el botón derecho en la caja de herramientas AdvancedHighQualityPrinting y haga clic en Agregar > Secuencia de comandos.
2. En el cuadro de diálogo Agregar secuencia de comandos, escriba AdvancedHighQualityPrinting en Nombre y en Etiqueta.
3. Haga clic en Siguiente.
4. Para el valor de Archivo de secuencia de comandos, desplácese hasta la carpeta WebApp, en la carpeta registrada y seleccione AdvancedHighQualityPrinting.py.
5. En el cuadro de diálogo Agregar secuencia de comandos, haga clic en Siguiente.
6. Se deben añadir cinco parámetros a la herramienta de secuencia de comandos.
   1. El primer parámetro será Web_Map_as_JSON. Este parámetro toma una representación JSON del estado del mapa que se va a exportar tal y como aparece en la aplicación web. Las propiedades deben coincidir con la siguiente captura de pantalla:
      
   2. El siguiente parámetro será Format: el formato en el que se presentará la imagen de mapa para imprimir. Las propiedades deben coincidir con la siguiente captura de pantalla:
      
   3. El siguiente parámetro será Layout_Template: el documento de mapa de plantilla que se utilizará. Las propiedades deben coincidir con la siguiente captura de pantalla:
      
   4. El siguiente parámetro será Georef_info: una cadena booleana de caracteres que permite exportar información del sistema de coordenadas al archivo PDF de salida. Las propiedades deben coincidir con la siguiente captura de pantalla:
      
   5. El siguiente parámetro será Output_File: el archivo de salida que se creará. Las propiedades deben coincidir con la siguiente captura de pantalla:
      

      Precaución:

      Los nombres de parámetro Web_Map_as_JSON, Format, Layout_Template y Output_File deben escribirse exactamente como se muestra, para que coincidan con la firma de la herramienta de la tarea Imprimir en las API Web de ArcGIS. Para obtener más información sobre los parámetros, consulte Exportar mapa Web. El parámetro Georef_info es un parámetro adicional que se transmitirá a la tarea Imprimir y, por lo tanto, no tiene que adecuarse a ninguna convención de nomenclatura.

   6. En el cuadro de diálogo Agregar secuencia de comandos, haga clic en Finalizar.
7. Haga clic con el botón derecho en la herramienta de secuencia de comandos AdvancedHighQualityPrinting y haga clic en Descripción del elemento.
8. En el cuadro de diálogo Descripción del elemento, rellene los elementos Etiquetas y Resumen con el texto que elija. Además, rellene el campo Explicación del cuadro de diálogo de los cinco parámetros que hay en la sección Sintaxis del cuadro de diálogo Descripción del elemento. Si lo desea, rellene las demás descripciones del elemento.

Ejecutar la herramienta

La herramienta se debe ejecutar correctamente para poder crear un resultado en la ventana Resultados que se pueda publicar en ArcGIS for Server. Esto sirve para ilustrar un problema interesante con las secuencias de comandos de prueba que utilizan ConvertWebMapToMapDocument. Para ejecutarse localmente, necesita un JSON de mapa web válido. No obstante, ArcGIS API for JavaScript ofrecerán el JSON de mapa Web en la aplicación Web, aunque solo después de que se haya publicado la secuencia de comandos. Para solventar esto, puede usar el JSON de prueba que se encuentra en el tema de ayuda ConvertWebMapToMapDocument. Además, puede modificar el JSON para que contenga elementos que espera la herramienta y que serán similares a los del JSON que obtendrá de la aplicación web. En este tutorial, el usuario de la aplicación web va a activar y desactivar capas de servicio en el mapa, además de en la leyenda. Por tanto, deberá usarse una cadena de caracteres JSON de mapa web de prueba como esta:

{
    "operationalLayers": [
        {
            "url": "http://MyServer:6080/arcgis/rest/services/USA/ConterminousUSA/MapServer",
            "title": "MyDynamicService",
            "opacity": 1,
            "id": "MyDynamicService",
            "visibility": true,
            "visibleLayers": [
                0,
                2,
                3,
                4,
                5,
                6,
                7
            ]
        }
    ],
    "mapOptions": {
        "extent": {
            "xmin": -2200000,
            "ymin": 500000,
            "xmax": -1300000,
            "ymax": 1300000,
            "spatialReference": {
                "wkid": 102008
            }
        },
        "scale": 5000000,
        "rotation": 0
    },
    "layoutOptions": {
        "copyrightText": "",
        "authorText": "",
        "legendOptions": {
            "operationalLayers": [
                {
                    "id": "MyDynamicService",
                    "subLayerIds": [
                        0,
                        2,
                        5
                    ]
                }
            ]
        }
    }
}

Observe que el elemento visibleLayers tiene la capa 1 desactivada. Esto significa que la capa uno del servicio de mapa no estará presente en la salida. Observe también los subLayerIDs en legendOptions. En la leyenda solo estarán las capas 0, 2 y 5. Esto es similar al JSON que devolverá la aplicación web. Para obtener más información, consulte las Especificaciones del JSON de mapa Web.

Cuando se está ejecutando la herramienta de secuencia de comandos, la cadena de caracteres JSON puede copiarse y pegarse en el parámetro de entrada Web_Map_as_JSON. Sin embargo, es necesario quitar los saltos de línea para que la cadena de caracteres sea una entrada válida. La cadena de caracteres JSON con los saltos de línea quitados se muestra a continuación:

{"operationalLayers":[{"url":"http://MyServer:6080/arcgis/rest/services/USA/ConterminousUSA/MapServer","title":"MyDynamicService","opacity":1,"id":"MyDynamicService","visibility":true,"visibleLayers":[0,2,3,4,5,6,7]}],"mapOptions":{"extent":{"xmin":-2200000,"ymin":500000,"xmax":-1300000,"ymax":1300000,"spatialReference":{"wkid":102008}},"scale":5000000,"rotation":0},"layoutOptions":{"copyrightText":"","authorText":"","legendOptions":{"operationalLayers":[{"id":"MyDynamicService","subLayerIds":[0,2,5]}]}}}

También debe cambiar el nombre del servidor (MyServer:6080, más arriba) por el de su servidor de ArcGIS for Server.

Sugerencia:

A efectos de publicación, puede optar por dejar el parámetro de entrada Web_Map_as_JSON en blanco, ya que ArcGIS API for JavaScript proporcionará el JSON de mapa Web en la aplicación Web. Puede dejar el parámetro de entrada Web_Map_as_JSON en blanco siempre que la secuencia de comandos de Python se haya escrito de tal forma que no provoque errores si se queda en blanco. Por ejemplo, la secuencia de comandos no busca capas del mapa web por nombre. Si la secuencia de comandos provoca un fallo en el servidor debido a un error, tendrá que arreglarse localmente y, a continuación, volverse a publicar en el servidor. Por lo tanto, es aconsejable asegurarse de que la secuencia de comandos funcione localmente antes de publicarla, probando con una cadena de caracteres JSON de mapa web válida o usando un documento de mapa de depuración que contenga todos los elementos que habría en el JSON de mapa web. En este tutorial, facilitaremos una cadena de caracteres JSON válida.

1. En la ventana Catálogo, haga clic con el botón derecho en la herramienta de secuencia de comandos AdvancedHighQualityPrinting y haga clic en Abrir.
2. Para el parámetro de entrada Web_Map_as_JSON, copie y pegue la cadena de caracteres JSON con los saltos de línea quitados desde el bloque de código de una sola línea que figura más arriba en el parámetro Web_Map_as_JSON. No olvide cambiar el nombre del servidor para que coincida con el suyo. El cuadro de diálogo de la herramienta de secuencia de comandos AdvancedHighQualityPrinting debe tener este aspecto:
   
3. Acepte todos los valores predeterminados de los demás parámetros y haga clic en Aceptar.
4. Abra la ventana Resultados .
5. Haga doble clic en Output_File, resaltado a continuación, para ver el PDF de salida.
   

   De esta manera se abrirá el PDF. Tal y como se especifica en el JSON de mapa web, el PDF debe tener la capa uno desactivada en el mapa y solo las capas 0, 2 y 5 activadas en la leyenda.

Publique el resultado

El resultado ya está listo para publicarse como servicio de geoprocesamiento. Si no está familiarizado con la publicación de los servicios de geoprocesamiento, consulte:

¿Qué es un servicio de geoprocesamiento?Un recorrido rápido por los servicios de creación e intercambioUn recorrido rápido por la publicación de un servicio de geoprocesamientoVocabulario esencial para los servicios de geoprocesamiento

1. En la ventana Resultados , haga clic con el botón derecho en el resultado AdvancedHighQualityPrinting y haga clic en Compartir como > Servicio de geoprocesamiento.
2. Haga clic en Publicar un servicio.
3. Haga clic en Siguiente.
4. Elija una conexión de publicación o administración con el equipo de ArcGIS for Server.
5. Haga clic en Siguiente.
6. Utilice la carpeta existente denominada USA.
7. Haga clic en Continuar.
8. En la esquina superior derecha del Editor de servicios, haga clic en Publicar.
9. Después de la correcta publicación de la herramienta de secuencias de comandos, es aconsejable probar el servicio de geoprocesamiento en ArcMap utilizando una conexión de servidor SIG a ArcGIS for Server. Puede ver el resultado del servicio de geoprocesamiento en la ventana Resultados de geoprocesamiento.

El servicio de geoprocesamiento ya está listo para utilizarse en las API web de ArcGIS.

Código de ejemplo de ArcGIS API for JavaScript

Use el siguiente código de ejemplo para crear su aplicación web.

En el siguiente ejemplo de código de ArcGIS API for JavaScript, cambie la dirección URL al servicio de mapa y servicio de geoprocesamiento que creó en los pasos anteriores para que coincida con el nombre de su servidor. Se mencionan en estas líneas:

var dynUrl = "http://MyServer:6080/arcgis/rest/services/USA/ConterminousUSA/MapServer";

var printUrl = "http://MyServer:6080/arcgis/rest/services/USA/AdvancedHighQualityPrinting/GPServer/AdvancedHighQualityPrinting";

Código para AdvancedHighQualityPrinting.html:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
    <meta http-equiv="X-UA-Compatible" content="IE=7,IE=9" />
    <meta name="viewport" content="initial-scale=1, maximum-scale=1,user-scalable=no"/>
    <link rel="stylesheet" type="text/css" href="http://serverapi.arcgisonline.com/jsapi/arcgis/3.0/js/dojo/dijit/themes/claro/claro.css">
    <script src="http://serverapi.arcgisonline.com/jsapi/arcgis/3.0/"></script>
    <script type="text/javascript" language="Javascript">
      dojo.require("esri.map");
      dojo.require("esri.tasks.PrintTask");
      dojo.require("dijit.form.Button");
      dojo.require("dijit.form.CheckBox");
      dojo.require("dijit.form.ComboBox");

      var layer, map, visible = [];
      var printTask, params;

      function init() {
        var startExtent = new esri.geometry.Extent({
          "xmin" : -2260000,
          "ymin" : -1500000,
          "xmax" : 2250000,
          "ymax" : 1220000,
          "spatialReference" : {
            "wkid" : 102008
          }
        });
        map = new esri.Map("map", {
          extent : startExtent
        });

        var dynUrl = "http://MyServer:6080/arcgis/rest/services/USA/ConterminousUSA/MapServer";
        layer = new esri.layers.ArcGISDynamicMapServiceLayer(dynUrl, {
          "id" : "ConterminousUSA"
        });

        if (layer.loaded) {
          buildLayerList(layer);
        } else {
          dojo.connect(layer, "onLoad", buildLayerList);
        }

        var printUrl = "http://MyServer:6080/arcgis/rest/services/USA/AdvancedHighQualityPrinting/GPServer/AdvancedHighQualityPrinting";
        printTask = new esri.tasks.PrintTask(printUrl, {
          async : true
        });
        params = new esri.tasks.PrintParameters();
        params.map = map;
      }

      function buildLayerList(layer) {
        var items = dojo.map(layer.layerInfos, function(info, index) {
          if (info.defaultVisibility) {
            visible.push(info.id);
          }
          return "<input type='checkbox' class='list_item' checked='" + (info.defaultVisibility ? "checked" : "") + "' id='" + info.id + "' onclick='updateLayerVisibility();' /><label for='" + info.id + "'>" + info.name + "</label>";
        });

        dojo.byId("layer_list").innerHTML = items.join();

        layer.setVisibleLayers(visible);
        map.addLayer(layer);

      }

      function updateLayerVisibility() {
        var inputs = dojo.query(".list_item"), input;

        visible = [];

        dojo.forEach(inputs, function(input) {
          if (input.checked) {
            visible.push(input.id);
          }
        });
        //if there aren't any layers visible set the array to be -1
        if (visible.length === 0) {
          visible.push(-1);
        }
        layer.setVisibleLayers(visible);
      }

      function print() {
        var layout = dojo.byId("layout");
        var index = layout.selectedIndex;
        var selectedValue_layout = layout.options[index].value;
        var format = dojo.byId("format");
        var index = format.selectedIndex;
        var selectedValue_format = format.options[index].value;
        var georef_info = dojo.byId("georef_info");
        var index = georef_info.selectedIndex;
        var selectedValue_georef_info = georef_info.options[index].value;

        var legendLayer = new esri.tasks.LegendLayer();
        legendLayer.layerId = "ConterminousUSA";
        legendLayer.subLayerIds = [];
        if (CapitalCities.checked == true) {
          legendLayer.subLayerIds.push(0);
        }
        if (InterstateHighways.checked == true) {
          legendLayer.subLayerIds.push(1);
        }
        if (Rivers.checked == true) {
          legendLayer.subLayerIds.push(2);
        }
        if (Lakes.checked == true) {
          legendLayer.subLayerIds.push(3);
        }
        if (StateBoundaries.checked == true) {
          legendLayer.subLayerIds.push(4);
        }

        params.template = {
          layout : selectedValue_layout,
          format : selectedValue_format,
          layoutOptions : {
            legendLayers : [legendLayer]
          }
        };
        params.extraParameters = {
          Georef_info : selectedValue_georef_info
        };
        printTask.execute(params, printComplete);
      }

      function printComplete(result) {
        window.open(result.url);
      }


      dojo.addOnLoad(init);

    </script>

  </head>

  <body class="claro">
    <div id="map" style="width:1000px; height:600px; border:1px solid #000;"></div>
    <br />
    Layout Template:
    <select id="layout" >
      <OPTION value="CentralUSA">CentralUSA</OPTION>
      <OPTION value="ConterminuousUSA">ConterminuousUSA</OPTION>
      <OPTION value="NortheasternUSA">NortheasternUSA</OPTION>
      <OPTION value="NorthwesternUSA">NorthwesternUSA</OPTION>
      <OPTION value="SouthernUSA">SouthernUSA</OPTION>
      <OPTION value="SouthwesternUSA">SouthwesternUSA</OPTION>
    </select>
    &nbsp;&nbsp;Format:
    <select id="format">
      <OPTION value="PDF">PDF</OPTION>
      <OPTION value="PNG">PNG</OPTION>
    </select>
	
    &nbsp;&nbsp;Include Georef info?
    <select id="georef_info">
      <OPTION value="True">True</OPTION>
      <OPTION value="False">False</OPTION>
    </select>
    <br />
    <br />
    Table of Contents:
    <br />
    <span id="layer_list"></span>
    <br />
    <br />
    Include in Legend:
    <br />
    <label>
      <input type="checkbox" name="CapitalCities" id="CapitalCities" checked="checked">
      Capital Cities</label>
    <label>
      <input type="checkbox" name="InterstateHighways" id="InterstateHighways" checked="checked">
      Interstate Highways</label>
    <label>
      <input type="checkbox" name="Rivers" id="Rivers" checked="checked">
      Rivers</label>
    <label>
      <input type="checkbox" name="Lakes" id="Lakes" checked="checked">
      Lakes</label>
    <label>
      <input type="checkbox" name="StateBoundaries" id="StateBoundaries" checked="checked">
      State Boundaries</label>
    <br />
    <br />
    <input type="button" id="print" value="Print" onclick="print();"/>
  </body>
</html>

Ejecutar la aplicación web

Ejecute la aplicación web que creó en el paso anterior. Consulte la documentación de ArcGIS API for JavaScript para obtener instrucciones sobre cómo ejecutar las aplicaciones Web, si es necesario. A continuación figura una captura de pantalla de la aplicación web. Observe que Capital Cities está desactivada en la Tabla de contenido. Observe además que State Boundaries está desactivada en Incluir en la leyenda.

Poco después de hacer clic en el botón Exportar mapa, aparecerá automáticamente un archivo de salida. La siguiente ilustración muestra un ejemplo de PDF de salida apto para su impresión. Observe que las capas que se habían desactivado en la Tabla de contenido y en Incluir en la leyenda, en la aplicación web, se reflejan en la salida. Además, el PDF utiliza los datos de vectores que se incluyeron provisionalmente en las plantillas de diseño, en lugar de una imagen de las capas de servicio. El archivo de salida también contendrá otros elementos que se presentaron en los documentos de mapa de plantilla: una leyenda, marco de datos, texto dinámico del sistema de coordenadas y una barra de escala. Si el usuario seleccionó el parámetro Georef info para que fuera True, el PDF de salida también contendrá información de georreferenciación, que puede verse en Adobe Reader utilizando la herramienta de localización geoespacial.

Aquí concluye el tutorial de impresión/exportación avanzadas de mapas web con arcpy.mapping. Para consultar un tutorial de impresión básica de mapas web, consulte el tutorial de impresión/exportación básicas de mapas web.