Buscador

Buscador

Trabaje con nosotros

Smart Mapping con espacios de trabajo dinámicos

Por  Kristian Ekenes, Mayo 25 de 2016


No hace mucho tiempo escribí un post acerca de cómo y por qué es posible utilizar SmartMapping en aplicaciones web personalizadas que utilizan el API de ArcGIS para JavaScript. El ejemplo que aparece en ese post muestra cómo cambiar dinámicamente la simbología de un FeatureLayer con el módulo de SmartMapping y los widgets deslizantes.

Desde el lanzamiento del mapeo inteligente, algunos usuarios han preguntado acerca de cómo utilizar el módulo de SmartMapping para cambiar la representación predeterminada de capas dinámicas basadas en atributos de tablas combinadas en los espacios de trabajo dinámicos. El siguiente ejemplo muestra cómo lograr esto.

Vive un ejemplo en vivo

Mira el código sobre GitHub

Este flujo de trabajo es útil en los casos en los que tiene varias tablas con decenas, incluso cientos de atributos útiles para la visualización. La creación de un servicio de entidades o la publicación de todas las tablas de un servicio de mapas dinámico puede ser poco práctico debido a la larga cantidad de tiempo que puede tomar para cargar grandes servicios en aplicaciones web. En su lugar, puede crear un servicio de mapas que contiene sólo las geometrías y los atributos mínimos y habilitar espacios de trabajo dinámicos a través de su Administrador de ArcGIS for Server. Esto permitirá que se registre bases de datos y directorios a un espacio de trabajo dinámico, proporcionando su servicio de acceso a los recursos en tablas combinadas en tiempo de ejecución. Esto mantiene el servicio y proporciona acceso a potencialmente cientos de atributos que pueden ser utilizados para fines de visualización.

Información general del ejemplo

En el ejemplo anterior le sumamos una instancia ArcGISDynamicMapServiceLayer al mapa. La capa contiene varias subcapas - cada uno contiene características con geometrías de diferentes resoluciones: grupos de bloques, condados y estados. El servicio contiene un buen número de atributos, incluyendo estadísticas de población basadas en la edad, género, estado civil, etc.

Podemos cambiar el procesador de cada capa a base de cualquiera de estos atributos, pero queremos explorar otro conjunto de atributos que contienen estadísticas de ascendencia que no existen en la propia capa. Los atributos de ascendencia residen en una tabla combinada que se hace referencia en un espacio de trabajo dinámico establecido por el administrador del servicio. Queremos que el usuario seleccione un país en un menú desplegable y entonces hace una llamada al módulo SmartMapping para cambiar la simbología de cada estado en función del porcentaje de personas que pueden rastrear su ascendencia en el país seleccionado.

Antes de entrar en algunos de los detalles de esta muestra, tenga en cuenta que el render generado con el módulo SmartMapping sólo admite para FeatureLayer. Usted puede solicitar la extracción del render generado con SmartMapping a las capas dinámicas, pero esto requiere solicitudes de red adicionales para el cálculo de las estadísticas necesarias para crear un procesador que se ajuste a sus datos. Así que este flujo de trabajo puede ser un poco complicado y todavía llevan un costo de rendimiento.

Crear una capa dinámica con una tabla combinada

En primer lugar tenemos que crear una capa dinámica con una fuente de datos unidos. Para lograr esto, debemos crear un objeto JoinDataSource, que contiene información para las tablas de izquierda y derecha y sus respectivas claves para llevar a cabo la unión.

            var joinDataSource = new JoinDataSource({
  joinType: "left-outer-join",
  //
  // Sets the left table source (layer with geometries) to the joinDataSource
  // object. All we need to specify is the sublayer id of the map layer.
  //
  leftTableSource: new LayerMapSource({
 type: "mapLayer",
    mapLayerId: 3 // The index of the states sublayer
  }),
  // the field in the map service indicating the state name
  leftTableKey: "STATE_NAME",
  // the field in the joining table indicating the state name
  rightTableKey: "State",
  //
  // Sets the right table source (the attribute table to join) to
  // the states layer in the map service. This object will be used to complete
  // the join to the dynamic service (the layer with the geometries).
  //
  rightTableSource: new LayerDataSource({
    dataSource: new TableDataSource({
      type: "table",  // indicates the data source is a table
      // workspace where the table resides (defined in ArcGIS Server Manager)
      workspaceId: "CensusFileGDBWorkspaceID",  
      dataSourceName: "ancestry"  // the table name
    })
  })
});

          

Mira el código sobre GitHub

A continuación, añadimos el JoinDataSource como fuente a un objeto DynamicLayerInfo, que se establece a continuación, en el ArcGISDynamicMapServiceLayer. Esto completa el proceso de la unión. Ahora todos los atributos de la tabla de ascendencia están disponibles para la capa de censo.

  //
// Create the dynamic layer data source for a DynamicLayerInfo instance.
// This is a join data source and completes the join between the table
// full of attributes and the layer containing geometries.
//

var dynamicLayerDataSource = new LayerDataSource({
dataSource: joinDataSource  // this data source was created in the previous step
});

// Creates an array of dynamicLayerInfo objects for all sublayers in the service
var dynamicLayerInfosArray = censusMapServiceLayer.createDynamicLayerInfosFromLayerInfos();

// Find the dynamicLayerInfo object for the states sublayer
var dynamicLayerInfo = dynamicLayerInfosArray.find(function(dynamicLayerInfoItem){
  return dynamicLayerInfoItem.name === "states";
});

// set the dynamic layer info object on the census map service layer
dynamicLayerInfo.source = dynamicLayerDataSource;
censusMapServiceLayer.setDynamicLayerInfos([dynamicLayerInfo], true);

Mira el código sobre GitHub

Crear un FeatureLayer

SmartMapping sólo admite FeatureLayer. Por lo tanto, aprovechar las capacidades SmartMapping en este caso de uso, debemos crear una instancia FeatureLayer utilizado exclusivamente para la generación de un render predeterminado. Tenga en cuenta que la url de la capa debe apuntar al punto final dynamicLayer en el servicio de mapas y la fuente de la capa debe apuntar al objeto dynamicLayerDataSource que hemos creado en el paso anterior. Esto garantiza que el FeatureLayer tiene acceso a la tabla unida en el espacio de trabajo dinámico.

  //
// Create a FeatureLayer with the joined data source so the SmartMapping
// module can access the data in the joined table for generating a
// renderer to apply to the DynamicLayer. SmartMapping can only
// generate renderers based on FeatureLayer instances.
//
// Set options for the feature layer instance
var layerOptions = {
  mode: FeatureLayer.MODE_SELECTION,
  outFields: ["*"],
  // set the source to the JoinDataSource so the SmartMapping module
  // can have access to the data in the fields from the joined table
  source: dynamicLayerDataSource
};

// Create the layer with the url to the dynamic layer
var featureLayer = new FeatureLayer(layerUrl + "/dynamicLayer", layerOptions);

Mira el código sobre GitHub

Generar un render

Ahora todo lo que tenemos que hacer es usar la instancia Feature Layer para generar un render con valores predeterminados e inteligentes basados en el campo de ascendencia seleccionado por el usuario. En el siguiente fragmento de código, llamamos al método createClassedColorRenderer () para generar una ClassBreaksRenderer basada en el color. Observe cómo se utiliza el FeatureLayer como parámetro de entrada para generar el renderizador, pero el procesador de sí misma se establece en el drawingInfo de la capa dinámica con una instancia del módulo LayerDrawingOptions.

  smartMapping.createClassedColorRenderer({
  // selected by the user
  basemap: basemapStyle,
  classificationMethod: "natural-breaks",
  // ancestry table field selected by the user
  field: ancestryClassificationField,
  // featureLayer created in the previous step
  layer: featureLayer,
  // normalize by the total population
  // note the field name is prefixed by 'states'.
  // this indicates the workspace where the field
  // is located - the states sublayer of the service
normalizationField: "states.POP2007",
  normalizationType: "field",
  numClasses: 7
}).then(function (response){

  var optionsArray = [];
  // Create a LayerDrawingOptions object used to set
  // a renderer on a sublayer of a DynamicLayer
  var drawingOptions = new LayerDrawingOptions();
  // Set the response renderer on the drawing options
  drawingOptions.renderer = response.renderer;

  // And place the drawing options in index 3 so it applies to the states sublayer
  optionsArray[3] = drawingOptions;
  // set the renderer on the layer
  censusMapServiceLayer.setLayerDrawingOptions(optionsArray);
});

Mira el código sobre GitHub

Conclusión

Este ejemplo agrega una instancia ArcGISDynamicMapServiceLayer al mapa y actualiza su capa visible (s) y la simbología sobre utilizando un render generado desde el módulo SmartMapping. Esto le permite explorar los datos en tablas combinadas en los espacios de trabajo dinámicos y cambiar la visualización de una capa dinámica. Tenga en cuenta que no todos los renders generados por el módulo SmartMapping, incluyendo el color y el tamaño, no se pueden utilizar en la versión actual de MapServer. El apoyo a la aplicación de estos renders a capas dinámicas está prevista para futuras versiones.

Los fragmentos proporcionados anteriormente representan las piezas más esenciales de código necesarios para este flujo de trabajo para la función. Revisar el código de la aplicación para ver cada una de estas piezas en su contexto.

Fuentes

Blog ArcGIS

https://blogs.esri.com/esri/arcgis/2016/05/25/smart-mapping-with-dynamic-workspaces/

  • ArcGIS 10
  • Andorid
  • ArcGiS Android
  • ArcGIS Runtime SDK
  • ArcGIS Runtime SDK for Android
  • Developers
  • Java