Esempio n. 1
0
        // Create a unique value renderer by state sub-region name
        private async Task SetupSymbology()
        {
            try
            {
                // Generate a unique value renderer on the server
                GenerateRendererTask generateRendererTask = new GenerateRendererTask(new Uri(LAYER_URL));

                UniqueValueDefinition uvDef = new UniqueValueDefinition()
                {
                    Fields = new List <string> {
                        "sub_region"
                    }
                };
                uvDef.ColorRamps.Add(new ColorRamp()
                {
                    From = Colors.Purple, To = Colors.Yellow, Algorithm = Algorithm.LabLch
                });
                GenerateRendererParameters rendererParams = new GenerateRendererParameters()
                {
                    ClassificationDefinition = uvDef
                };

                var rendererResult = await generateRendererTask.GenerateRendererAsync(rendererParams);

                _graphicsOverlay.Renderer = rendererResult.Renderer;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Statistics Sample");
            }
        }
        // Create a unique value renderer by state sub-region name
        private async Task SetUniqueRenderer()
        {
            try
            {
                // Generate a unique value renderer on the server
                GenerateRendererTask generateRendererTask = new GenerateRendererTask(new Uri(LAYER_URL));

                UniqueValueDefinition uvDef = new UniqueValueDefinition()
                {
                    Fields = new string[] { "sub_region" }
                };
                uvDef.ColorRamps.Add(new ColorRamp()
                {
                    From = Colors.Purple, To = Colors.Yellow, Algorithm = Algorithm.LabLch
                });
                GenerateRendererParameter rendererParams = new GenerateRendererParameter()
                {
                    ClassificationDefinition = uvDef
                };

                var rendererResult = await generateRendererTask.GenerateRendererAsync(rendererParams);

                _graphicsLayer.Renderer = rendererResult.Renderer;
            }
            catch (Exception ex)
            {
                var _ = new MessageDialog(ex.Message, "Sample Error").ShowAsync();
            }
        }
        public GenerateRenderer()
        {
            InitializeComponent();

            generateRendererTask = new GenerateRendererTask();
            generateRendererTask.Url = "http://sampleserver6.arcgisonline.com/arcgis/rest/services/Census/MapServer/2";
            generateRendererTask.ExecuteCompleted += generateRendererTask_ExecuteCompleted;
            generateRendererTask.Failed += generateRendererTask_Failed;
        }
Esempio n. 4
0
        public GenerateRenderer()
        {
            InitializeComponent();

            generateRendererTask     = new GenerateRendererTask();
            generateRendererTask.Url = "http://sampleserver6.arcgisonline.com/arcgis/rest/services/Census/MapServer/2";
            generateRendererTask.ExecuteCompleted += generateRendererTask_ExecuteCompleted;
            generateRendererTask.Failed           += generateRendererTask_Failed;
        }
        public DynamicLayerRendering()
        {
            this.InitializeComponent();

            var layer = mapView.Map.Layers.OfType<ArcGISDynamicMapServiceLayer>().FirstOrDefault();
            layer.VisibleLayers = new ObservableCollection<int>() { 2 };

            // Create GenerateRendererTask for a specific map layer
            generateRendererTask = new GenerateRendererTask(new Uri("http://sampleserver6.arcgisonline.com/arcgis/rest/services/Census/MapServer/2"));
        }
Esempio n. 6
0
        public DynamicLayerRendering()
        {
            InitializeComponent();

            DataContext = this;
            IsBusy      = false;

            // Create GenerateRendererTask for a specific map layer
            generateRendererTask = new GenerateRendererTask(new Uri("http://sampleserver6.arcgisonline.com/arcgis/rest/services/Census/MapServer/2"));
        }
        public DynamicLayerRendering()
        {
            InitializeComponent();

            DataContext = this;
            IsBusy = false;

            // Create GenerateRendererTask for a specific map layer
            generateRendererTask = new GenerateRendererTask(new Uri("http://sampleserver6.arcgisonline.com/arcgis/rest/services/Census/MapServer/2"));
        }
        public DynamicLayerRendering()
        {
            this.InitializeComponent();

            var layer = mapView.Map.Layers.OfType <ArcGISDynamicMapServiceLayer>().FirstOrDefault();

            layer.VisibleLayers = new ObservableCollection <int>()
            {
                2
            };

            // Create GenerateRendererTask for a specific map layer
            generateRendererTask = new GenerateRendererTask(new Uri("http://sampleserver6.arcgisonline.com/arcgis/rest/services/Census/MapServer/2"));
        }
        // When field to summarize on changes, generate a new renderer from the map service
        private async void comboField_SelectionChanged(object sender, Windows.UI.Xaml.Controls.SelectionChangedEventArgs e)
        {
            try
            {
                // Generate a new renderer
                GenerateRendererTask generateRenderer = new GenerateRendererTask(
                    new Uri("http://sampleserver6.arcgisonline.com/arcgis/rest/services/Census/MapServer/2"));

                var colorRamp = new ColorRamp()
                {
                    Algorithm = Algorithm.Hsv,
                    From      = Color.FromArgb(0xFF, 0x99, 0x8E, 0xC3),
                    To        = Color.FromArgb(0xFF, 0xF1, 0xA3, 0x40)
                };

                var classBreaksDef = new ClassBreaksDefinition()
                {
                    BreakCount           = 5,
                    ClassificationField  = ((Windows.UI.Xaml.Controls.ComboBoxItem)comboField.SelectedItem).Tag as string,
                    ClassificationMethod = ClassificationMethod.Quantile,
                    BaseSymbol           = _baseSymbol,
                    ColorRamps           = new ObservableCollection <ColorRamp>()
                    {
                        colorRamp
                    }
                };

                var param = new GenerateRendererParameters()
                {
                    ClassificationDefinition = classBreaksDef,
                    Where = ((ServiceFeatureTable)_featureLayer.FeatureTable).Where
                };

                var result = await generateRenderer.GenerateRendererAsync(param);

                _featureLayer.Renderer = result.Renderer;

                // Reset the legend
                txtLegendTitle.DataContext = comboField.SelectedValue.ToString();
                await CreateLegend((ClassBreaksRenderer)result.Renderer);
            }
            catch (Exception ex)
            {
                var _x = new MessageDialog(ex.Message, "Sample Error").ShowAsync();
            }
        }
        private void InitializeRenderingInfo()
        {
            FeatureLayer statesFeatureLayer = MyMap.Layers["StatesFeatureLayer"] as FeatureLayer;

            generateRendererTask = new GenerateRendererTask(statesFeatureLayer.Url);

            generateClassesParameters = new GenerateRendererParameters();
            generateClassesParameters.Source = new LayerMapSource() { MapLayerID = 3 };

            generateRendererTask.Failed += (s, e) =>
            {
                MessageBox.Show(string.Format("GenerateRendererTask Failed: {0}", e.Error.Message));
            };
            generateRendererTask.ExecuteCompleted += (s, e) =>
            {
                statesFeatureLayer.Renderer = e.GenerateRendererResult.Renderer;
            };
        }
        // Create a unique value renderer by state sub-region name
		private async Task SetupSymbology()
        {
            try
            {
                // Generate a unique value renderer on the server
                GenerateRendererTask generateRendererTask = new GenerateRendererTask(new Uri(LAYER_URL));

                UniqueValueDefinition uvDef = new UniqueValueDefinition() { Fields = new List<string> { "sub_region" } };
                uvDef.ColorRamps.Add(new ColorRamp() { From = Colors.Purple, To = Colors.Yellow, Algorithm = Algorithm.LabLch });
                GenerateRendererParameters rendererParams = new GenerateRendererParameters() { ClassificationDefinition = uvDef };

                var rendererResult = await generateRendererTask.GenerateRendererAsync(rendererParams);
				_graphicsOverlay.Renderer = rendererResult.Renderer;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Statistics Sample");
            }
        }
        // When field to summarize on changes, generate a new renderer from the map service
        private async void comboField_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                // Generate a new renderer
                GenerateRendererTask generateRenderer = new GenerateRendererTask(
                    new Uri("http://sampleserver6.arcgisonline.com/arcgis/rest/services/Census/MapServer/2"));

                var colorRamp = new ColorRamp()
                {
                    Algorithm = Algorithm.Hsv,
                    From = Color.FromRgb(0x99, 0x8E, 0xC3),
                    To = Color.FromRgb(0xF1, 0xA3, 0x40)
                };

                var classBreaksDef = new ClassBreaksDefinition()
                {
                    BreakCount = 5,
                    ClassificationField = ((ComboBoxItem)comboField.SelectedItem).Tag as string,
                    ClassificationMethod = ClassificationMethod.Quantile,
                    BaseSymbol = _baseSymbol,
                    ColorRamps = new ObservableCollection<ColorRamp>() { colorRamp }
                };

                var param = new GenerateRendererParameters()
                {
                    ClassificationDefinition = classBreaksDef,
                    Where = ((ServiceFeatureTable)featureLayer.FeatureTable).Where
                };

                var result = await generateRenderer.GenerateRendererAsync(param);

                featureLayer.Renderer = result.Renderer;

                // Reset the legend
                txtLegendTitle.DataContext = comboField.SelectedValue.ToString();
                await CreateLegend((ClassBreaksRenderer)result.Renderer);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Generate Renderer Task Sample");
            }
        }
        // Create a unique value renderer by state sub-region name
        private async Task SetUniqueRenderer()
        {
            try
            {
                // Generate a unique value renderer on the server
                GenerateRendererTask generateRendererTask = new GenerateRendererTask(new Uri(LAYER_URL));

                UniqueValueDefinition uvDef = new UniqueValueDefinition() { Fields = new string[] { "sub_region" } };
                uvDef.ColorRamps.Add(new ColorRamp() { From = Colors.Purple, To = Colors.Yellow, Algorithm = Algorithm.LabLch });
                GenerateRendererParameter rendererParams = new GenerateRendererParameter() { ClassificationDefinition = uvDef };

                var rendererResult = await generateRendererTask.GenerateRendererAsync(rendererParams);
                _graphicsLayer.Renderer = rendererResult.Renderer;
            }
            catch (Exception ex)
            {
                var _ = new MessageDialog(ex.Message, "Sample Error").ShowAsync();
            }
        }
Esempio n. 14
0
        private void InitializeRenderingInfo()
        {
            FeatureLayer statesFeatureLayer = MyMap.Layers["StatesFeatureLayer"] as FeatureLayer;

            generateRendererTask = new GenerateRendererTask(statesFeatureLayer.Url);

            generateClassesParameters        = new GenerateRendererParameters();
            generateClassesParameters.Source = new LayerMapSource()
            {
                MapLayerID = 3
            };

            generateRendererTask.Failed += (s, e) =>
            {
                MessageBox.Show(string.Format("GenerateRendererTask Failed: {0}", e.Error.Message));
            };
            generateRendererTask.ExecuteCompleted += (s, e) =>
            {
                statesFeatureLayer.Renderer = e.GenerateRendererResult.Renderer;
            };
        }
Esempio n. 15
0
        public StatisticsRenderOnMap()
        {
            InitializeComponent();

            subRegionGraphicsLayer = MyMap.Layers["SumGraphicsLayer"] as GraphicsLayer;

            // Generate a unique value renderer on the server
            GenerateRendererTask generateRendererTask = new GenerateRendererTask();

            generateRendererTask.Url = _layerUrl;

            generateRendererTask.ExecuteCompleted += (o, e) =>
            {
                subRegionGraphicsLayer.Renderer = e.GenerateRendererResult.Renderer;
            };

            UniqueValueDefinition uniqueValueDefinition = new UniqueValueDefinition()
            {
                Fields = new List <string>()
                {
                    "SUB_REGION"
                }
            };

            uniqueValueDefinition.ColorRamps.Add(new ColorRamp()
            {
                From      = Colors.Purple,
                To        = Colors.Yellow,
                Algorithm = Algorithm.LabLChAlgorithm
            });

            GenerateRendererParameters rendererParams = new GenerateRendererParameters()
            {
                ClassificationDefinition = uniqueValueDefinition,
            };

            generateRendererTask.ExecuteAsync(rendererParams);

            // When layers initialized, return all states, generate statistics for a group,
            // union graphics based on grouped statistics
            MyMap.Layers.LayersInitialized += (a, b) =>
            {
                QueryTask queryTask1     = new QueryTask(_layerUrl);
                Query     queryAllStates = new Query()
                {
                    ReturnGeometry      = true,
                    OutSpatialReference = MyMap.SpatialReference,
                    Where = "1=1"
                };
                queryAllStates.OutFields.Add("SUB_REGION");

                queryTask1.ExecuteCompleted += (c, d) =>
                {
                    // Return statistics for states layer. Population and total count of states grouped by sub-region.
                    QueryTask queryTask2 = new QueryTask(_layerUrl);
                    Query     query      = new Query()
                    {
                        GroupByFieldsForStatistics = new List <string> {
                            "SUB_REGION"
                        },

                        OutStatistics = new List <OutStatistic> {
                            new OutStatistic()
                            {
                                OnStatisticField      = "POP2000",
                                OutStatisticFieldName = "SubRegionPopulation",
                                StatisticType         = StatisticType.Sum
                            },
                            new OutStatistic()
                            {
                                OnStatisticField      = "SUB_REGION",
                                OutStatisticFieldName = "NumberOfStates",
                                StatisticType         = StatisticType.Count
                            }
                        }
                    };
                    queryTask2.ExecuteCompleted += (e, f) =>
                    {
                        // foreach group (sub-region) returned from statistic results
                        foreach (Graphic regionGraphic in f.FeatureSet.Features)
                        {
                            // Collection of graphics based on sub-region
                            IEnumerable <Graphic> toUnion =
                                (f.UserState as FeatureSet).Features.Where(stateGraphic =>
                                                                           (string)stateGraphic.Attributes["SUB_REGION"] ==
                                                                           (string)regionGraphic.Attributes["SUB_REGION"]);

                            // Union graphics based on sub-region, add to graphics layer
                            GeometryService geometryService =
                                new GeometryService("http://sampleserver6.arcgisonline.com/arcgis/rest/services/Utilities/Geometry/GeometryServer");
                            geometryService.UnionCompleted += (g, h) =>
                            {
                                Graphic unionedGraphic = h.UserState as Graphic;
                                unionedGraphic.Geometry = h.Result;
                                subRegionGraphicsLayer.Graphics.Add(unionedGraphic);
                            };
                            geometryService.UnionAsync(toUnion.ToList(), regionGraphic);
                        }

                        // populate the ListBox
                        FeatureSet featureSet = f.FeatureSet;
                        if (featureSet != null && featureSet.Features.Count > 0)
                        {
                            OutStatisticsListBox.ItemsSource = featureSet.Features;
                        }
                    };

                    queryTask2.ExecuteAsync(query, d.FeatureSet);
                };

                queryTask1.ExecuteAsync(queryAllStates);
            };
        }
        public StatisticsRenderOnMap()
        {
            InitializeComponent();

            subRegionGraphicsLayer = MyMap.Layers["SumGraphicsLayer"] as GraphicsLayer;

            // Generate a unique value renderer on the server
            GenerateRendererTask generateRendererTask = new GenerateRendererTask();
            generateRendererTask.Url = _layerUrl;

            generateRendererTask.ExecuteCompleted += (o, e) =>
            {
                subRegionGraphicsLayer.Renderer = e.GenerateRendererResult.Renderer;
            };

            UniqueValueDefinition uniqueValueDefinition = new UniqueValueDefinition()
            {
                Fields = new List<string>() { "SUB_REGION" }
            };

            uniqueValueDefinition.ColorRamps.Add(new ColorRamp()
            {
                From = Colors.Purple,
                To = Colors.Yellow,
                Algorithm = Algorithm.LabLChAlgorithm
            });

            GenerateRendererParameters rendererParams = new GenerateRendererParameters()
            {
                ClassificationDefinition = uniqueValueDefinition,
            };

            generateRendererTask.ExecuteAsync(rendererParams);

            // When layers initialized, return all states, generate statistics for a group,
            // union graphics based on grouped statistics
            MyMap.Layers.LayersInitialized += (a, b) =>
              {
                  QueryTask queryTask1 = new QueryTask(_layerUrl);
                  Query queryAllStates = new Query()
                  {
                      ReturnGeometry = true,
                      OutSpatialReference = MyMap.SpatialReference,
                      Where = "1=1"
                  };
                  queryAllStates.OutFields.Add("SUB_REGION");

                  queryTask1.ExecuteCompleted += (c, d) =>
                      {
                          // Return statistics for states layer. Population and total count of states grouped by sub-region.
                          QueryTask queryTask2 = new QueryTask(_layerUrl);
                          Query query = new Query()
                          {
                              GroupByFieldsForStatistics = new List<string> { "SUB_REGION" },

                              OutStatistics = new List<OutStatistic> {
                                new OutStatistic(){
                                    OnStatisticField = "POP2000",
                                    OutStatisticFieldName = "SubRegionPopulation",
                                    StatisticType = StatisticType.Sum
                                },
                                new OutStatistic(){
                                    OnStatisticField = "SUB_REGION",
                                    OutStatisticFieldName = "NumberOfStates",
                                    StatisticType = StatisticType.Count
                                }
                             }
                          };
                          queryTask2.ExecuteCompleted += (e, f) =>
                          {
                              // foreach group (sub-region) returned from statistic results
                              foreach (Graphic regionGraphic in f.FeatureSet.Features)
                              {
                                  // Collection of graphics based on sub-region
                                  IEnumerable<Graphic> toUnion =
                                      (f.UserState as FeatureSet).Features.Where(stateGraphic =>
                                          (string)stateGraphic.Attributes["SUB_REGION"] ==
                                          (string)regionGraphic.Attributes["SUB_REGION"]);

                                  // Union graphics based on sub-region, add to graphics layer
                                  GeometryService geometryService =
                                      new GeometryService("http://sampleserver6.arcgisonline.com/arcgis/rest/services/Utilities/Geometry/GeometryServer");
                                  geometryService.UnionCompleted += (g, h) =>
                                  {
                                      Graphic unionedGraphic = h.UserState as Graphic;
                                      unionedGraphic.Geometry = h.Result;
                                      subRegionGraphicsLayer.Graphics.Add(unionedGraphic);
                                  };
                                  geometryService.UnionAsync(toUnion.ToList(), regionGraphic);
                              }

                              // populate the ListBox
                              FeatureSet featureSet = f.FeatureSet;
                              if (featureSet != null && featureSet.Features.Count > 0)
                              {
                                  OutStatisticsListBox.ItemsSource = featureSet.Features;
                              }
                          };

                          queryTask2.ExecuteAsync(query, d.FeatureSet);
                      };

                  queryTask1.ExecuteAsync(queryAllStates);
              };
        }