Tutorial: impresión/exportación básicas de mapas Web de alta calidad mediante arcpy.mapping
En este tutorial, creará una aplicación Web en la que el usuario final podrá desplazarse hasta un área de interés y pulsar un botón Imprimir. El resultado será un documento PDF apto para su impresión con una salida de vectores de alta calidad para capas de servicio.
De forma predeterminada, la exportación desde una aplicación Web utilizando el servicio de Herramientas de impresión preconfiguradas y sus widgets de impresión de cliente en las API Web de ArcGIS genera una imagen de las capas de servicio, que puede tener una resolución demasiado baja (por ejemplo, 96 dpi) para impresiones a gran formato o salidas cartográficas de alta calidad. Esto es especialmente cierto si sus capas de servicio utilizan una caché de mapa en teselas. En este caso, el resultado de las capas de servicio será una imagen en caché en teselas.
La siguiente ilustración muestra dos ejemplos de archivos PDF de salida. La imagen de la izquierda muestra el aspecto que tendría una caché en teselas de capas de servicio si exportara un PDF a gran formato y ha acercado la visualización. Observe lo borrosas que aparecen las entidades y el texto pixelado. Podría verse bien con una escala más pequeña o en caché. También puede verse correctamente a tamaño folio o doble folio, pero, probablemente, no a un tamaño mayor.
La imagen de la derecha muestra datos de vector. Es mucho más lisa y sería más apropiada para una salida cartográfica de alta calidad. En este tutorial se le enseñará a personalizar una solución de impresión preconfigurada para generar un documento PDF apto para su impresión que contiene una salida de vectores de alta calidad para capas de servicio.
En la aplicación Web que va a crear, generará equivalentes en vectores del servicio de mapa base topográfico mundial. En el centro de recursos de ArcGIS hay disponible un subconjunto de vectores del servicio de mapa base topográfico mundial.
Nota:Para generar un documento de salida que contenga datos vectoriales de alta calidad en lugar de una imagen de caché en teselas de capas de servicio, debe tener acceso a los datos vectoriales.
La siguiente ilustración muestra la aplicación Web que va a crear.
El código que subyace al botón Imprimir en la aplicación Web utiliza la tarea Imprimir de las API Web de ArcGIS, disponible con ArcGIS 10.1 for Server. 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. La plantilla contiene equivalentes en vectores de todas las capas posibles en el servicio de mapas. El módulo arcpy.mapping también ofrece funciones para eliminar capas de servicio, dejando datos vectoriales locales que se presentaron en el documento de mapa de plantilla, y para exportar a PDF.
Después de hacer clic en el botón Imprimir, el resultado será un documento PDF apto para su impresión con datos vectoriales de alta calidad, en lugar de una imagen de caché en teselas de capas de servicio.
Para completar este tutorial, debe estar familiarizado con el módulo arcpy.mapping, las API Web de ArcGIS, ArcGIS for Desktop y ArcGIS 10.1 for Server. En este tutorial se incluyen ejemplos de código de todas las API Web de ArcGIS. También debe familiarizarse con la impresión en los temas de ayuda de la aplicación Web:
Obtener los datos vectoriales desde el centro de recursos de ArcGIS
Descargará un archivo zip de la galería de plantillas de mapa, en el centro de recursos de ArcGIS, que contiene los datos vectoriales que se usarán en la plantilla de documento de mapa presentada.
Antes de hacerlo, debe asegurarse de que haya una estructura de carpetas en la que ArcGIS for Server pueda ver el documento 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 con ArcGIS for Server. Para obtener más información sobre cómo registrar los datos con ArcGIS for Server, consulte:
Sugerencia:Cuando utilice documentos de mapa de plantilla en la función ConvertWebMapToMapDocument, lo más recomendable es usar datos que estén registrados con 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.
- Abra una nueva sesión vacía de ArcMap.
- En la ventana Catálogo, desplácese hasta la carpeta registrada. Cree una nueva carpeta en la carpeta registrada llamada BasicTutorial.
- Diríjase a la galería de plantilla de mapas, en el centro de recursos de ArcGIS. Seleccione la plantilla Topographic Map Template - Medium Scales.
- Descargue el archivo zip Topographic Map Template - Medium Scales en su equipo haciendo clic en el botón Descargar.
- Extraiga el contenido del archivo zip en la carpeta BasicTutorial de la carpeta registrada.
- La carpeta registrada debe tener un aspecto similar a la siguiente ilustración.
Nota:En la captura de pantalla anterior, la carpeta registrada se llama MyDataStore. La carpeta registrada puede tener el nombre que desee.
Prepare el documento de mapa que usar como plantilla en la aplicación Web.
Los datos que ha descargado del centro de recursos de ArcGIS contienen dos documentos de mapa. MediumScales_anno.mxd se usará en la aplicación Web. El mapa y los datos están previstos para su uso con escalas medianas; por ejemplo, aproximadamente, de 1:1.500.000 a 1:18.000. Eliminará el rango de escala máximo en el documento de mapa para que los usuarios de la aplicación Web puedan acercar la visualización más allá de la escala máxima y aún así puedan generar una impresión.
- Abra MediumScales_anno.mxd en ArcMap.
- Haga clic con el botón derecho en la capa de grupo Nivel 14 ~1:36K, en la tabla de contenido, y haga clic en Propiedades.
- Haga clic en la pestaña General.
- Defina la lista desplegable No mostrar la capa con zoom de acercamiento más allá de como <Ninguno>.
- Haga clic en Aceptar en el cuadro de diálogo Propiedades del Grupo de Capas.
- Guarde el documento de mapa.
El documento de mapa ya está listo para ser utilizado 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 impresión de geoprocesamiento personalizado.
La secuencia de comandos de Python en el servicio de impresión 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 elimina las capas de servicio en el documento de mapa de salida, dejando las capas de vectores que se correspondan con la capa de servicio en el JSON del mapa Web. El JSON del mapa Web contiene la extensión del mapa en la aplicación Web. Por último, la secuencia de comandos exporta el documento de mapa a PDF.
- Abra cualquier IDE de Python, como IDLE (que viene con ArcGIS for Desktop).
- Copie y pegue el siguiente código en una nueva secuencia de comandos de Python.
- Cambie la variable templateMxd para que sea la ruta UNC hasta la carpeta de la carpeta registrada que contiene los documentos de mapa de la plantilla.
- Guarde la secuencia de comandos de Python. Dé a la secuencia de comandos el nombre BasicTutorial.py. Guárdela en una carpeta llamada WebApp dentro de la carpeta registrada.
import arcpy
import os
import uuid
# Input WebMap json
Web_Map_as_JSON = arcpy.GetParameterAsText(0)
# The template location in the server data store
templateMxd = '//zoid/MyDataStore/BasicTutorial/Maps and GDBs/MediumScales_Anno.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]
# Remove the service layer
# This will just leave the vector layers from the template
for lyr in arcpy.mapping.ListLayers(mxd, data_frame=df):
if lyr.isServiceLayer:
arcpy.mapping.RemoveLayer(df, lyr)
# Use the uuid module to generate a GUID as part of the output name
# This will ensure a unique output name
output = 'WebMap_{}.pdf'.format(str(uuid.uuid1()))
Output_File = os.path.join(arcpy.env.scratchFolder, output)
# Export the WebMap
arcpy.mapping.ExportToPDF(mxd, Output_File)
# Set the output parameter to be the output file of the server job
arcpy.SetParameterAsText(1, Output_File)
# Clean up - delete the map document reference
filePath = mxd.filePath
del mxd, result
os.remove(filePath)
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 serán necesarias. En lugar de ello, pueden usarse rutas absolutas.
Crear una herramienta de secuencia de comandos de Python
Creará una herramienta de geoprocesamiento personalizada que ejecute la secuencia de comandos BasicTutorial.py.
- En la ventana Catálogo, en ArcMap, desplácese hasta la carpeta WebApp, en el directorio de la carpeta registrada.
- Haga clic con el botón derecho en la carpeta WebApp y haga clic en Nuevo > Caja de herramientas. Asigne el nombre BasicTutorial a la caja de herramientas.
- Haga clic con el botón derecho en la caja de herramientas BasicTutorial y haga clic en Descripción del elemento.
- 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.
- Haga clic en Guardar y salga del cuadro de diálogo Descripción del elemento.
- En la ventana Catálogo, haga clic con el botón derecho en la caja de herramientas BasicTutorial y haga clic en Agregar > Secuencia de comandos.
- En el cuadro de diálogo Agregar secuencia de comandos, escriba BasicTutorial en Nombre y en Etiqueta.
- Haga clic en Siguiente.
- Para el valor de Archivo de secuencia de comandos, desplácese hasta la carpeta WebApp, en la carpeta registrada, y seleccione BasicTutorial.py.
- Haga clic en Siguiente.
- Se deben agregar dos parámetros a la herramienta de secuencia de comandos.
- El primero 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:
- El siguiente parámetro es 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 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.
- En el cuadro de diálogo Agregar secuencia de comandos, haga clic en Finalizar.
- El primero 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:
- Haga clic con el botón derecho en la herramienta de secuencia de comandos BasicTutorial y haga clic en Descripción del elemento.
- 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 cuatro parámetros que hay en la sección Sintaxis del cuadro de diálogo Descripción del elemento con el texto que elija. Si lo desea, rellene las demás descripciones del elemento.
Ejecutar la herramienta
La herramienta debe ejecutarse correctamente para poder crear un resultado en la ventana Resultados que pueda publicarse en ArcGIS for Server.
- En la ventana Catálogo, haga clic con el botón derecho en la herramienta de secuencia de comandos BasicTutorial y haga clic en Abrir.
- Deje el parámetro de entrada Web_Map_as_JSON en blanco.Sugerencia:
A efectos de publicación, puede dejar el parámetro de entrada Web_Map_as_JSON en blanco, ya que las API Web de ArcGIS proporcionarán 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.
- Haga clic en Aceptar. Espere a que la herramienta termine de ejecutarse.
El resultado ya está listo para publicarse como servicio de geoprocesamiento.
Publique el resultado
Si no está familiarizado con la publicación de los servicios de geoprocesamiento, consulte:
- Abra la ventana Resultados.
- Expanda Sesión actual.
- Haga clic con el botón derecho en el resultado BasicTutorial y haga clic en Compartir como > Servicio de geoprocesamiento.
- Marque Publicar un servicio.
- Haga clic en Siguiente.
- Elija una conexión de publicación o administración con el servidor de ArcGIS 10.1 for Server.
- Haga clic en Siguiente.
- Haga clic en Siguiente.
- Haga clic en Continuar.
- En la esquina superior derecha del Editor de servicios, haga clic en Publicar.
El servicio de geoprocesamiento ya está listo para utilizarse en las API Web de ArcGIS.
Elija qué API Web de ArcGIS desea usar para crear la aplicación Web.
Las API Web de ArcGIS ofrecen una funcionalidad SIG similar; es decir, puede elegir la plataforma para desarrollador que prefiera. Escapa al ámbito de este tutorial entrar en detalles sobre cómo crear aplicaciones Web con cada API. Consulte la documentación de la API para ello. Para obtener más información, consulte:
Cada API Web de ArcGIS tiene una tarea Imprimir. La tarea Imprimir tiene una propiedad URL que hará referencia al servicio de geoprocesamiento personalizado que creó anteriormente. Consulte la documentación de la API Web de ArcGIS para obtener más información sobre la tarea Imprimir.
En las secciones siguientes, use los códigos de ejemplo correspondientes a la API Web de ArcGIS en la que trabaje para crear su aplicación Web.
Código de ejemplo de ArcGIS API for JavaScript
Si está usando ArcGIS API for JavaScript, use el siguiente código de ejemplo para crear su aplicación Web.
En el siguiente código de ejemplo de ArcGIS API for JavaScript, cambie la URL al servicio de mapa y servicio de geoprocesamiento que creó en un paso anterior para que coincida con el nombre de su servidor. Se menciona en esta línea:
var printUrl = "http://MyServer:6080/arcgis/rest/services/BasicTutorial/GPServer/BasicTutorial";
Código para BasicTutorial.html:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Webmap Printing</title>
<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/?v=3.0"></script>
<script type="text/javascript" language="Javascript">
dojo.require("esri.map");
dojo.require("esri.tasks.PrintTask");
var printTask, params;
function init() {
// limit scales in webmap to the usable scales of the template map document
var lods = [ {"level" : 11, "resolution" : 76.4370282850732, "scale" : 288895.277144},
{"level" : 12, "resolution" : 38.2185141425366, "scale" : 144447.638572},
{"level" : 13, "resolution" : 19.1092570712683, "scale" : 72223.819286},
{"level" : 14, "resolution" : 9.55462853563415, "scale" : 36111.909643},
{"level" : 15, "resolution" : 4.77731426794937, "scale" : 18055.954822}];
// set the extent to the Portland area - which matches the extent of the template map document
var startExtent = new esri.geometry.Extent({"xmin":-13679000,"ymin":5680000,
"xmax":-13635000,"ymax":5740000,
"spatialReference":{"wkid":102100}});
var map = new esri.Map("map", {extent:startExtent, lods:lods});
// add tiled map service to webmap
var tiledUrl = "http://server.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer";
var tiledLayer = new esri.layers.ArcGISTiledMapServiceLayer(tiledUrl);
map.addLayer(tiledLayer);
var printUrl = "http://MyServer:6080/arcgis/rest/services/BasicTutorial/GPServer/BasicTutorial";
printTask = new esri.tasks.PrintTask(printUrl, {async: true});
params = new esri.tasks.PrintParameters();
params.map = map;
}
function print(){
var ptemplate = new esri.tasks.PrintTemplate();
// use the extent of the webmap in the output PDF
ptemplate.preserveScale = false;
params.template = ptemplate;
printTask.execute(params, printComplete);
}
function printComplete(result){
window.open(result.url);
}
dojo.addOnLoad(init);
</script>
</head>
<body class="claro">
<input type="button" id="print" value="Print" onclick="print();"/>
<div id="map" style="width:1000px; height:600px; border:1px solid #000;"></div>
</body>
</html>
Código de ejemplo de ArcGIS API for Flex
Si está usando ArcGIS API for Flex, use el siguiente código de ejemplo para crear su aplicación Web.
En el siguiente código de ejemplo de ArcGIS API for Flex, cambie la URL al servicio de mapa y servicio de geoprocesamiento que creó en un paso anterior para que coincida con el nombre de su servidor. Se menciona en estas líneas:
url="http://MyServer:6080/arcgis/rest/services/BasicTutorial/GPServer/BasicTutorial"/>
Código para BasicTutorial.mxml:
<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
xmlns:s="library://ns.adobe.com/flex/spark"
xmlns:esri="http://www.esri.com/2008/ags"
initialize="printTask.getServiceInfo()"
pageTitle="High-quality printing">
<fx:Script>
<![CDATA[
import com.esri.ags.events.PrintEvent;
import com.esri.ags.tasks.supportClasses.DataFile;
import com.esri.ags.tasks.supportClasses.JobInfo;
import com.esri.ags.tasks.supportClasses.ParameterValue;
import mx.controls.Alert;
public var preserveScale:Boolean = true;
private function printBtn_clickHandler(event:MouseEvent):void
{
if (printTask.getServiceInfoLastResult.isServiceAsynchronous)
{
printTask.submitJob(printParameters);
}
else
{
printTask.execute(printParameters);
}
}
private function printTask_jobCompleteHandler(event:PrintEvent):void
{
var jobInfo:JobInfo = event.jobInfo;
if (jobInfo.jobStatus == JobInfo.STATUS_SUCCEEDED)
{
printTask.getResultData(jobInfo.jobId);
}
else
{
Alert.show(jobInfo.jobStatus);
}
}
private function printTask_getResultDataCompleteHandler(event:PrintEvent):void
{
var dataFile:DataFile = event.parameterValue.value as DataFile;
navigateToURL(new URLRequest(dataFile.url));
}
private function printTask_executeCompleteHandler(event:PrintEvent):void
{
var paramValue:ParameterValue = event.executeResult.results[0];
var dataFile:DataFile = paramValue.value as DataFile;
navigateToURL(new URLRequest(dataFile.url));
}
]]>
</fx:Script>
<fx:Declarations>
<esri:PrintTask id="printTask"
executeComplete="printTask_executeCompleteHandler(event)"
fault="Alert.show(event.fault.faultString)"
getResultDataComplete="printTask_getResultDataCompleteHandler(event)"
jobComplete="printTask_jobCompleteHandler(event)"
showBusyCursor="false"
url="http://MyServer:6080/arcgis/rest/services/BasicTutorial/GPServer/BasicTutorial"/>
<esri:PrintParameters id="printParameters"
preserveScale="false"
map="{map}">
</esri:PrintParameters>
<esri:Extent id="initialExtent"
xmin="-13679000" ymin="5680000" xmax="-13635000" ymax="5740000">
<esri:SpatialReference wkid="102100"/>
</esri:Extent>
</fx:Declarations>
<s:controlBarLayout>
<s:HorizontalLayout gap="10"
paddingBottom="7"
paddingLeft="10"
paddingRight="10"
paddingTop="7"
verticalAlign="baseline"/>
</s:controlBarLayout>
<s:controlBarContent>
<s:Button id="printBtn"
click="printBtn_clickHandler(event)"
enabled="{printTask.getServiceInfoLastResult != null}"
label="Print"/>
</s:controlBarContent>
<esri:Map id="map" extent="{initialExtent}">
<esri:lods>
<esri:LOD resolution="76.4370282850732" scale="288895.277144"/>
<esri:LOD resolution="38.2185141425366" scale="144447.638572"/>
<esri:LOD resolution="19.1092570712683" scale="72223.819286"/>
<esri:LOD resolution="9.55462853563415" scale="36111.909643"/>
<esri:LOD resolution="4.77731426794937" scale="18055.954822"/>
</esri:lods>
<esri:ArcGISTiledMapServiceLayer url="http://server.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer"/>
</esri:Map>
</s:Application>
Código de ejemplo de ArcGIS API for Silverlight
Si está usando ArcGIS API for Silverlight, use el siguiente código de ejemplo para crear su aplicación Web.
Código XAML:
<UserControl x:Class="Basic_Tutorial.MainPage"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:esri="http://schemas.esri.com/arcgis/client/2009">
<Grid x:Name="LayoutRoot" Background="White">
<esri:Map x:Name="MyMap" Extent="-13679000,5680000,-13635000,5740000">
<esri:Map.Layers>
<esri:ArcGISTiledMapServiceLayer ID="MyTiledService"
Url="http://server.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer"/>
</esri:Map.Layers>
</esri:Map>
<StackPanel Orientation="Vertical" Margin="15" HorizontalAlignment="Left" VerticalAlignment="Top" >
<Border x:Name="PrintPanel" CornerRadius="10" BorderBrush="Gray" BorderThickness="1" Background="White" HorizontalAlignment="Left"
VerticalAlignment="Top" Margin="15" Padding="10">
<Border.Effect>
<DropShadowEffect/>
</Border.Effect>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition />
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition/>
</Grid.RowDefinitions>
<Button x:Name="Print" Content="Print" Click="ExportMap_Click"
Grid.Row="1" Grid.Column="0" Margin="2"/>
</Grid>
</Border>
</StackPanel>
</Grid>
</UserControl>
En el siguiente código de ejemplo de ArcGIS API for Silverlight, cambie la URL al servicio de geoprocesamiento que creó en un paso anterior para que coincida con el nombre de su servidor. Se menciona en esta línea:
printTask = new PrintTask("http://MyServer:6080/arcgis/rest/services/BasicTutorial/GPServer/BasicTutorial");
Código subyacente en C#:
using System;
using System.Windows;
using System.Windows.Controls;
using ESRI.ArcGIS.Client.Printing;
using ESRI.ArcGIS.Client.Tasks;
namespace Basic_Tutorial
{
public partial class MainPage : UserControl
{
PrintTask printTask;
public MainPage()
{
InitializeComponent();
printTask = new PrintTask("http://MyServer:6080/arcgis/rest/services/BasicTutorial/GPServer/BasicTutorial");
printTask.DisableClientCaching = true;
printTask.JobCompleted += new EventHandler<PrintJobEventArgs>(printTask_JobCompleted);
printTask.GetServiceInfoCompleted += new EventHandler<ServiceInfoEventArgs>(printTask_GetServiceInfoCompleted);
printTask.GetServiceInfoAsync();
}
void printTask_GetServiceInfoCompleted(object sender, ServiceInfoEventArgs e)
{
PrintPanel.DataContext = e.ServiceInfo;
}
void printTask_JobCompleted(object sender, PrintJobEventArgs e)
{
if (e.Error == null)
{
if (e.PrintResult != null)
System.Windows.Browser.HtmlPage.Window.Navigate(e.PrintResult.Url, "_blank");
}
}
private void ExportMap_Click(object sender, RoutedEventArgs e)
{
if (printTask == null || printTask.IsBusy) return;
PrintParameters printParameters = new PrintParameters(MyMap)
{
};
printTask.SubmitJobAsync(printParameters);
}
}
}
Ejecutar la aplicación Web
Ejecute la aplicación Web que creó en el paso anterior. Consulte la documentación de la API Web de ArcGIS 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 de la API Web de ArcGIS for JavaScript.
Acerque la visualización a un área de interés y haga clic en el botón Imprimir. El PDF de salida aparecerá automáticamente después de un momento. El resultado será un documento PDF apto para su impresión con datos vectoriales de alta calidad presentados en las plantillas de diseño, en lugar de imágenes de caché en teselas de capas de servicio. Esto genera una salida cartográfica de mayor calidad. A continuación figura un ejemplo de salida:
Aquí concluye el tutorial de impresión/exportación básicas de mapas Web de alta calidad. Para ver situaciones más avanzadas, consulte el Tutorial de impresión/exportación avanzadas de mapas Web de alta calidad.