private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-155.733, 95.60, 104.42, -81.9);

            LayerOverlay worldOverlay = new LayerOverlay();
            wpfMap1.Overlays.Add("WorldOverlay", worldOverlay);

            BackgroundLayer backgroundLayer = new BackgroundLayer(new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean));
            worldOverlay.Layers.Add(backgroundLayer);

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            worldOverlay.Layers.Add("WorldLayer", worldLayer);

            // If you want to use file cache which saves images to the disk;
            // When loading back the same tile, we'll find from the disk first.
            // Turn the cache on enhance the performance a lot;
            // if your map image is static, we recommend to turn the cache on.
            // It's off by default.
            FileBitmapTileCache bitmapTileCache = new FileBitmapTileCache();
            bitmapTileCache.CacheDirectory = @"..\..\SampleData\Data\SampleCacheTiles";
            bitmapTileCache.CacheId = "World02CachedTiles";
            bitmapTileCache.TileAccessMode = TileAccessMode.ReadOnly;
            bitmapTileCache.ImageFormat = TileImageFormat.Png;
            worldOverlay.TileCache = bitmapTileCache;
            worldOverlay.TransitionEffect = TransitionEffect.None;

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-135.224054810107, 62.2893787272533, -58.8379651537011, 7.78687151295263);

            WorldMapKitWmsWpfOverlay worldMapKitOverlay = new WorldMapKitWmsWpfOverlay();
            wpfMap1.Overlays.Add(worldMapKitOverlay);

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.Open();
            Feature feature = worldLayer.QueryTools.GetFeatureById("137", new string[0]);
            worldLayer.Close();

            InMemoryFeatureLayer inMemoryLayer = new InMemoryFeatureLayer();
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(100, GeoColor.SimpleColors.Green);
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.GeographicColors.DeepOcean;
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            inMemoryLayer.InternalFeatures.Add("POLYGON", feature);

            InMemoryFeatureLayer bufferLayer = new InMemoryFeatureLayer();
            bufferLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(100, GeoColor.SimpleColors.Green);
            bufferLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay inmemoryOverlay = new LayerOverlay();
            inmemoryOverlay.TransitionEffect = TransitionEffect.None;
            inmemoryOverlay.Layers.Add("InMemoryFeatureLayer", inMemoryLayer);
            wpfMap1.Overlays.Add("InmemoryOverlay", inmemoryOverlay);

            LayerOverlay bufferOverlay = new LayerOverlay();
            bufferOverlay.TransitionEffect = TransitionEffect.None;
            bufferOverlay.Layers.Add("BufferLayer", bufferLayer);
            wpfMap1.Overlays.Add("BufferOverlay", bufferOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.Meter;

            // If want to know more srids, please refer Projections.rtf in Documentation folder.
            ManagedProj4Projection proj4Projection = new ManagedProj4Projection();
            proj4Projection.InternalProjectionParametersString = ManagedProj4Projection.GetEpsgParametersString(4326);
            proj4Projection.ExternalProjectionParametersString = ManagedProj4Projection.GetEpsgParametersString(2163);

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            worldLayer.FeatureSource.Projection = proj4Projection;

            worldLayer.Open();
            wpfMap1.CurrentExtent = worldLayer.GetBoundingBox();
            worldLayer.Close();

            LayerOverlay staticOverlay = new LayerOverlay();
            staticOverlay.TileType = TileType.SingleTile;
            staticOverlay.Layers.Add(new BackgroundLayer(new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean)));
            staticOverlay.Layers.Add("WorldLayer", worldLayer);
            wpfMap1.Overlays.Add(staticOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            try
            {
                wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
                wpfMap1.CurrentExtent = new RectangleShape(-87.7649869909628, 43.7975200004804, -87.6955215108997, 43.6913981287878);

                WorldMapKitWmsWpfOverlay worldMapKitOverlay = new WorldMapKitWmsWpfOverlay();
                wpfMap1.Overlays.Add(worldMapKitOverlay);

                SdfFeatureLayer sdfLayer = new SdfFeatureLayer(@"..\..\SampleData\Data\Sheboygan_CityLimits.sdf", null);
                sdfLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.FromArgb(100, GeoColor.SimpleColors.Green), GeoColor.SimpleColors.Green);
                sdfLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

                LayerOverlay dynamicOverlay = new LayerOverlay();
                dynamicOverlay.DrawingExceptionMode = DrawingExceptionMode.DrawException;
                dynamicOverlay.Layers.Add("WorldLayer", sdfLayer);
                dynamicOverlay.TileType = TileType.SingleTile;
                wpfMap1.Overlays.Add(dynamicOverlay);

                wpfMap1.Refresh();
            }
            catch (FileNotFoundException ex)
            {
                string message = "You should get Fdo dependencies from [Install-Path]\\Developer Reference\\System32, and put MapSuiteFdoExtensionx86 folder to System32 folder.\r\n\r\n" + ex.Message;
                MessageBox.Show(message, "FileNotFound", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK, (MessageBoxOptions)0);
            }
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;

            WorldMapKitWmsWpfOverlay worldMapKitOverlay = new WorldMapKitWmsWpfOverlay();
            wpfMap1.Overlays.Add(worldMapKitOverlay);

            InMemoryFeatureLayer inMemoryLayer = new InMemoryFeatureLayer();
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(100, GeoColor.SimpleColors.Green);
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.SimpleColors.Green;
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.Open();
            Feature feature = worldLayer.QueryTools.GetFeatureById("135", new string[0]);
            worldLayer.Close();

            inMemoryLayer.InternalFeatures.Add("135", feature);

            LayerOverlay inMemoryOverlay = new LayerOverlay();
            inMemoryOverlay.TileType = TileType.SingleTile;
            inMemoryOverlay.Layers.Add("InMemoryFeatureLayer", inMemoryLayer);
            wpfMap1.Overlays.Add("InMemoryOverlay", inMemoryOverlay);

            wpfMap1.CurrentExtent = new RectangleShape(-165.946875, 86.4359375, -35.86875, -6.3765625);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-133.2515625, 89.2484375, 126.9046875, -88.290625);

            WorldMapKitWmsWpfOverlay worldMapKitOverlay = new WorldMapKitWmsWpfOverlay();
            wpfMap1.Overlays.Add(worldMapKitOverlay);

            ShapeFileFeatureLayer worldShapeLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.SimpleColors.Transparent, GeoColor.FromArgb(100, GeoColor.SimpleColors.Green));
            worldShapeLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            ShapeFileFeatureLayer worldLabelLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLabelLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("DynamicPopulation", "Arial", 10, DrawingFontStyles.Regular, GeoColor.StandardColors.Red, 0, -12);
            worldLabelLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            worldLabelLayer.FeatureSource.CustomColumnFetch += new EventHandler<CustomColumnFetchEventArgs>(FeatureSource_CustomColumnFetch);

            LayerOverlay staticOverlay = new LayerOverlay();
            staticOverlay.TileType = TileType.SingleTile;
            staticOverlay.Layers.Add("WorldShapeLayer", worldShapeLayer);
            staticOverlay.Layers.Add("WorldLabelLayer", worldLabelLayer);
            wpfMap1.Overlays.Add(staticOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;

            ShapeFileFeatureLayer statesLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\USStates.shp");
            statesLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.State1;
            statesLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.LineJoin = DrawingLineJoin.Round;
            statesLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            ShapeFileFeatureLayer majorCitiesShapeLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\MajorCities.shp");
            majorCitiesShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.City1;
            majorCitiesShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = TextStyles.City1("AREANAME");
            majorCitiesShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle.BestPlacement = true;
            majorCitiesShapeLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay staticOverlay = new LayerOverlay();
            staticOverlay.Layers.Add(new BackgroundLayer(new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean)));
            staticOverlay.Layers.Add("WorldLayer", worldLayer);
            staticOverlay.Layers.Add("StatesLayer", statesLayer);
            staticOverlay.Layers.Add("MajorCitiesShapeLayer", majorCitiesShapeLayer);
            wpfMap1.Overlays.Add(staticOverlay);

            wpfMap1.CurrentExtent = new RectangleShape(-126.4, 48.8, -67.0, 19.0);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;

            ShapeFileFeatureLayer statesLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\USStates.shp");
            statesLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;
            statesLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            ShapeFileFeatureLayer worldLabelLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\USStates.shp");
            worldLabelLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("STATE_NAME", "Arial", 7, DrawingFontStyles.Bold, GeoColor.FromArgb(255, 91, 91, 91));
            worldLabelLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle.PointPlacement = PointPlacement.Center;
            worldLabelLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle.OverlappingRule = LabelOverlappingRule.NoOverlapping;
            worldLabelLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle.DuplicateRule = LabelDuplicateRule.NoDuplicateLabels;
            worldLabelLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            worldLabelLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle.LabelPositions.Add("33", new WorldLabelingCandidate("Kansas State", new PointShape(-91.3969, 28.1016)));
            worldLabelLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle.LabelPositions.Add("4", new WorldLabelingCandidate("North Dakota State", new PointShape(-101.09, 51.11)));
            worldLabelLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle.LabelPositions.Add("24", new WorldLabelingCandidate("California State", new PointShape(-126.2, 36.27)));

            LayerOverlay staticOverlay = new LayerOverlay();
            staticOverlay.Layers.Add(new BackgroundLayer(new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean)));
            staticOverlay.Layers.Add("WorldLayer", worldLayer);
            staticOverlay.Layers.Add("StatesLayer", statesLayer);
            staticOverlay.Layers.Add("worldLabelLayer", worldLabelLayer);
            wpfMap1.Overlays.Add(staticOverlay);

            wpfMap1.CurrentExtent = new RectangleShape(-126.4, 48.8, -67.0, 19.0);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-133.2515625, 89.2484375, 126.9046875, -88.290625);

            WorldMapKitWmsWpfOverlay worldMapKitOverlay = new WorldMapKitWmsWpfOverlay();
            wpfMap1.Overlays.Add(worldMapKitOverlay);

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.SimpleColors.Transparent, GeoColor.FromArgb(100, GeoColor.SimpleColors.Green));
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay worldOverlay = new LayerOverlay();
            worldOverlay.Layers.Add("WorldLayer", worldLayer);
            wpfMap1.Overlays.Add("WorldOverlay", worldOverlay);

            InMemoryFeatureLayer highlightLayer = new InMemoryFeatureLayer();
            highlightLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Evergreen1;
            highlightLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay highlightOverlay = new LayerOverlay();
            highlightOverlay.Layers.Add("HighlightLayer", highlightLayer);
            highlightOverlay.TileType = TileType.SingleTile;
            wpfMap1.Overlays.Add("HighlightOverlay", highlightOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-128.31093750000002, 95.25, 131.84531249999998, -63.65625);

            WorldMapKitWmsWpfOverlay worldMapKitOverlay = new WorldMapKitWmsWpfOverlay();
            wpfMap1.Overlays.Add(worldMapKitOverlay);

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.SimpleColors.Transparent, GeoColor.FromArgb(100, GeoColor.SimpleColors.Green));
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            InMemoryFeatureLayer usInMemoryLayer = new InMemoryFeatureLayer();
            usInMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.PointType = PointType.Bitmap;
            usInMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.Image = new GeoImage(@"..\..\SampleData\Data\United States.png");
            usInMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            usInMemoryLayer.InternalFeatures.Add("US", new Feature(-98.58, 39.57, "1"));

            InMemoryFeatureLayer chinaInMemoryLayer = new InMemoryFeatureLayer();
            chinaInMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.PointType = PointType.Bitmap;
            chinaInMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.Image = new GeoImage(@"..\..\SampleData\Data\China.png");
            chinaInMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            chinaInMemoryLayer.InternalFeatures.Add("CHINA", new Feature(104.72, 34.45, "2"));

            LayerOverlay staticOverlay = new LayerOverlay();
            staticOverlay.Layers.Add("WorldLayer", worldLayer);
            staticOverlay.Layers.Add("USInMemoryFeatureLayer", usInMemoryLayer);
            staticOverlay.Layers.Add("ChinaInMemoryFeatureLayer", chinaInMemoryLayer);
            wpfMap1.Overlays.Add(staticOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-96.115612954611919, 29.954823851075187, -96.105810851850961, 29.947472274004468);

            WorldMapKitWmsWpfOverlay worldMapKitOverlay = new WorldMapKitWmsWpfOverlay();
            wpfMap1.Overlays.Add(worldMapKitOverlay);

            ClassBreakStyle gridClassBreakStyle = new ClassBreakStyle("CellValue");
            gridClassBreakStyle.ClassBreaks.Add(new ClassBreak(double.MinValue, new AreaStyle(new GeoSolidBrush(GeoColor.SimpleColors.Transparent))));
            gridClassBreakStyle.ClassBreaks.Add(new ClassBreak(6.2, new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(100, 255, 0, 0)))));
            gridClassBreakStyle.ClassBreaks.Add(new ClassBreak(6.83, new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(100, 255, 128, 0)))));
            gridClassBreakStyle.ClassBreaks.Add(new ClassBreak(7.0, new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(100, 245, 210, 10)))));
            gridClassBreakStyle.ClassBreaks.Add(new ClassBreak(7.08, new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(100, 225, 255, 0)))));
            gridClassBreakStyle.ClassBreaks.Add(new ClassBreak(7.15, new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(100, 224, 251, 132)))));
            gridClassBreakStyle.ClassBreaks.Add(new ClassBreak(7.21, new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(100, 128, 255, 128)))));
            gridClassBreakStyle.ClassBreaks.Add(new ClassBreak(7.54, new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(100, 0, 255, 0)))));

            GridFeatureLayer gridFeatureLayer = new GridFeatureLayer(@"..\..\SampleData\Data\PhValues.grd");
            gridFeatureLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(gridClassBreakStyle);
            gridFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay staticOverlay = new LayerOverlay();
            staticOverlay.TileType = TileType.SingleTile;
            staticOverlay.Layers.Add("GridFeatureLayer", gridFeatureLayer);
            wpfMap1.Overlays.Add(staticOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-177.39584350585937, 83.113876342773437, -52.617362976074219, 14.550546646118164);

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");

            worldLayer.Open();
            Feature feature = worldLayer.QueryTools.GetFeatureById("135", new string[0]);
            areaBaseShape = (AreaBaseShape)feature.GetShape();
            worldLayer.Close();

            InMemoryFeatureLayer simplificationLayer = new InMemoryFeatureLayer();
            simplificationLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            simplificationLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;
            simplificationLayer.InternalFeatures.Add(feature);

            LayerOverlay simplificationOverlay = new LayerOverlay();
            simplificationOverlay.TileType = TileType.SingleTile;
            simplificationOverlay.Layers.Add(new BackgroundLayer(new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean)));
            simplificationOverlay.Layers.Add("SimplificationLayer", simplificationLayer);
            wpfMap1.Overlays.Add("SimplificationOverlay", simplificationOverlay);

            cmbSimplificationType.SelectedIndex = 0;
            cmbTolerance.SelectedIndex = 0;

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-133.2515625, 89.2484375, 126.9046875, -88.290625);

            WorldMapKitWmsWpfOverlay worldMapKitDesktopOverlay = new WorldMapKitWmsWpfOverlay();
            wpfMap1.Overlays.Add(worldMapKitDesktopOverlay);

            // Highlight the countries that are land locked and have a population greater than 10 million
            string expression = "(ToInt32(POP_CNTRY)>10000000) AND (ToChar(LANDLOCKED)='Y')";
            FleeBooleanStyle landLockedCountryStyle = new FleeBooleanStyle(expression);

            // You can access the static methods on these types.  We use this
            // to access the Convert.Toxxx methods to convert variable types
            landLockedCountryStyle.StaticTypes.Add(typeof(System.Convert));
            // The math class might be handy to include but in this sample we do not use it
            //landLockedCountryStyle.StaticTypes.Add(typeof(System.Math));

            landLockedCountryStyle.ColumnVariables.Add("POP_CNTRY");
            landLockedCountryStyle.ColumnVariables.Add("LANDLOCKED");

            landLockedCountryStyle.CustomTrueStyles.Add(new AreaStyle(new GeoPen(GeoColor.SimpleColors.Green, 2), new GeoSolidBrush(GeoColor.FromArgb(100, GeoColor.SimpleColors.Green))));
            landLockedCountryStyle.CustomFalseStyles.Add(AreaStyles.CreateSimpleAreaStyle(GeoColor.SimpleColors.Transparent, GeoColor.FromArgb(100, GeoColor.SimpleColors.Green)));

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp", ShapeFileReadWriteMode.ReadOnly);
            worldLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(landLockedCountryStyle);
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay worldOverlay = new LayerOverlay();
            worldOverlay.TileType = TileType.SingleTile;
            worldOverlay.Layers.Add("WorldLayer", worldLayer);
            wpfMap1.Overlays.Add("WorldOverlay", worldOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-97.745827547760484, 30.297694742808115, -97.728208518132988, 30.285123327073894);

            ShapeFileFeatureLayer roadLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\austinstreets.shp");
            roadLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            roadLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;

            LayerOverlay roadOverlay = new LayerOverlay();
            roadOverlay.Layers.Add(new BackgroundLayer(new GeoSolidBrush(GeoColor.FromArgb(255, 233, 232, 214))));
            roadOverlay.Layers.Add("RoadLayer", roadLayer);
            wpfMap1.Overlays.Add("RoadOverlay", roadOverlay);

            InMemoryFeatureLayer highlightLayer = new InMemoryFeatureLayer();
            highlightLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;
            highlightLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.InnerPen.Brush = new GeoSolidBrush(GeoColor.FromArgb(150, GeoColor.SimpleColors.Blue));
            highlightLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay highlightOverlay = new LayerOverlay();
            highlightOverlay.Layers.Add("HighlightLayer", highlightLayer);
            wpfMap1.Overlays.Add("HighlightOverlay", highlightOverlay);

            PopupOverlay popupOverlay = new PopupOverlay();
            wpfMap1.Overlays.Add("PopupOverlay", popupOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-180.0, 83.0, -20.0, -20.0);

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.Name = "Countries02";
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            ShapeFileFeatureLayer statesLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\USStates.shp");
            statesLayer.Name = "USStates";
            statesLayer.ZoomLevelSet.ZoomLevel04.DefaultAreaStyle = AreaStyles.State1;
            statesLayer.ZoomLevelSet.ZoomLevel04.DefaultAreaStyle.OutlinePen.LineJoin = DrawingLineJoin.Round;
            statesLayer.ZoomLevelSet.ZoomLevel04.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            ShapeFileFeatureLayer citiesLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\MajorCities.shp");
            citiesLayer.Name = "MajorCities";
            citiesLayer.ZoomLevelSet.ZoomLevel06.DefaultPointStyle = PointStyles.City1;
            citiesLayer.ZoomLevelSet.ZoomLevel06.DefaultTextStyle = TextStyles.City1("areaname");
            citiesLayer.ZoomLevelSet.ZoomLevel06.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay worldOverlay = new LayerOverlay();
            worldOverlay.Layers.Add(new BackgroundLayer(new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean)));
            worldOverlay.Layers.Add("WorldLayer", worldLayer);
            worldOverlay.Layers.Add("StatesLayer", statesLayer);
            worldOverlay.Layers.Add("CitiesLayer", citiesLayer);
            wpfMap1.Overlays.Add("WorldOverlay", worldOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(0, 100, 100, 0);
            wpfMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.StandardColors.White);

            InMemoryFeatureLayer inMemoryLayer = new InMemoryFeatureLayer();
            inMemoryLayer.InternalFeatures.Add("Polygon", new Feature("POLYGON((10 60,40 70,30 85, 10 60))"));
            inMemoryLayer.InternalFeatures.Add("Multipoint", new Feature("MULTIPOINT(10 20, 30 20,40 20, 10 30, 30 30, 40 30)"));
            inMemoryLayer.InternalFeatures.Add("Line", new Feature("LINESTRING(60 60, 70 70,75 60, 80 70, 85 60,95 80)"));
            inMemoryLayer.InternalFeatures.Add("Rectangle", new Feature(new RectangleShape(65, 30, 95, 15)));

            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(100, GeoColor.StandardColors.RoyalBlue);
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Blue;
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen = new GeoPen(GeoColor.FromArgb(200, GeoColor.StandardColors.Red), 5);
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolPen = new GeoPen(GeoColor.FromArgb(255, GeoColor.StandardColors.Green), 8);
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay inmemoryOverlay = new LayerOverlay();
            inmemoryOverlay.TileType = TileType.SingleTile;
            inmemoryOverlay.Layers.Add("InMemoryFeatureLayer", inMemoryLayer);
            wpfMap1.Overlays.Add("InmemoryOverlay", inmemoryOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(0, 100, 100, 0);

            // Setup the inMemoryLayer.
            InMemoryFeatureLayer inMemoryLayer = new InMemoryFeatureLayer();
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(125, GeoColor.StandardColors.Gray);
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            inMemoryLayer.InternalFeatures.Add("AreaShape1", new Feature("POLYGON((10 20,30 60,40 10,10 20))", "AreaShape1"));
            BaseShape shape = new EllipseShape(new PointShape(70, 70), 10, 20);
            shape.Id = "AreaShape2";
            inMemoryLayer.InternalFeatures.Add("AreaShape2", new Feature(shape));

            InMemoryFeatureLayer shortestLineLayer = new InMemoryFeatureLayer();
            shortestLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen.Color = GeoColor.StandardColors.Red;
            shortestLineLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay inMemoryOverlay = new LayerOverlay();
            inMemoryOverlay.TransitionEffect = TransitionEffect.None;
            inMemoryOverlay.Layers.Add("InMemoryFeatureLayer", inMemoryLayer);
            wpfMap1.Overlays.Add("InMemoryOverlay", inMemoryOverlay);

            LayerOverlay shortestLineOverlay = new LayerOverlay();
            shortestLineOverlay.TileType = TileType.SingleTile;
            shortestLineOverlay.Layers.Add("ShortestLineLayer", shortestLineLayer);
            wpfMap1.Overlays.Add("ShortestLineOverlay", shortestLineOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;

            ShapeFileFeatureLayer austinStreetsShapeLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\austinstreets.shp");
            austinStreetsShapeLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            austinStreetsShapeLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(LineStyles.LocalRoad1);

            ShapeFileFeatureLayer austinStreetsLabelLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\austinstreets.shp");
            austinStreetsLabelLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            TextStyle textStyle = TextStyles.LocalRoad1("FENAME");
            textStyle.TextLineSegmentRatio = double.MaxValue;
            textStyle.SplineType = SplineType.StandardSplining;
            austinStreetsLabelLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(textStyle);

            LayerOverlay austinStreetsOverlay = new LayerOverlay();
            austinStreetsOverlay.Layers.Add(new BackgroundLayer(new GeoSolidBrush(GeoColor.FromArgb(255, 233, 232, 214))));
            austinStreetsOverlay.Layers.Add("AustinStreetsShapeLayer", austinStreetsShapeLayer);
            austinStreetsOverlay.Layers.Add("AustinStreetsLabelLayer", austinStreetsLabelLayer);
            wpfMap1.Overlays.Add("AustinStreetsOverlay", austinStreetsOverlay);

            wpfMap1.CurrentExtent = new RectangleShape(-97.6881803712033, 30.3177912428115, -97.6723016938352, 30.3064615919325);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            try
            {
                wpfMap1.MapUnit = GeographyUnit.Meter;
                wpfMap1.CurrentExtent = new RectangleShape(2149408.38465815, 246471.365609125, 2204046.63635703, 213231.081162168);

                PersonalGeoDatabaseFeatureLayer worldLayer = new PersonalGeoDatabaseFeatureLayer(@"..\..\SampleData\Data\JORWD6gdb.mdb", null, null, "Mains");
                worldLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;
                worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

                LayerOverlay worldOverlay = new LayerOverlay();
                worldOverlay.DrawingExceptionMode = DrawingExceptionMode.DrawException;
                worldOverlay.Layers.Add(new BackgroundLayer(new GeoSolidBrush(GeoColor.FromArgb(255, 233, 232, 214))));
                worldOverlay.Layers.Add("WorldLayer", worldLayer);
                wpfMap1.Overlays.Add("WorldOverlay", worldOverlay);

                wpfMap1.Refresh();
            }
            catch (FileNotFoundException ex)
            {
                string message = "You should get Fdo dependencies from [Install-Path]\\Developer Reference\\System32\\, and put MapSuiteFdoExtensionx86 folder to System32 folder.\r\n\r\n" + ex.Message;
                MessageBox.Show(message, "FileNotFound", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK, (MessageBoxOptions)0);
            }
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-165.946875, 86.4359375, -35.86875, -6.3765625);

            WorldMapKitWmsWpfOverlay worldMapKitOverlay = new WorldMapKitWmsWpfOverlay();
            wpfMap1.Overlays.Add(worldMapKitOverlay);

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\USStates.shp");
            worldLayer.Open();
            Collection<Feature> allFeatures = worldLayer.QueryTools.GetAllFeatures(ReturningColumnsType.AllColumns);
            worldLayer.Close();

            // Setup the inMemoryLayer.
            InMemoryFeatureLayer inMemoryLayer = new InMemoryFeatureLayer();
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(100, GeoColor.SimpleColors.Green)));
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.SimpleColors.Green;
            inMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            foreach (Feature feature in allFeatures)
            {
                inMemoryLayer.InternalFeatures.Add(feature);
            }

            LayerOverlay inMemoryOverlay = new LayerOverlay();
            inMemoryOverlay.TileType = TileType.SingleTile;
            inMemoryOverlay.Layers.Add("InMemoryFeatureLayer", inMemoryLayer);
            wpfMap1.Overlays.Add("InMemoryOverlay", inMemoryOverlay);

            wpfMap1.Refresh();
        }
        public static LayerOverlay CreateCustomLayerOverlay()
        {
            const string customOverlayName = "Custom Overlay";

            //  Create a layeroverlay and set TileType as SingleTile. It means that the overlay is formed by one single tile.
            //  The TileType default value is MultipleTile
            LayerOverlay layerOverlay = new LayerOverlay() { TileType = TileType.SingleTile };
            layerOverlay.Name = customOverlayName;

            //  Create and initialize a projection. It will be apply to the FeatureSource create below.
            ManagedProj4Projection wgs84ToMercatorProjection = new ManagedProj4Projection();
            wgs84ToMercatorProjection.InternalProjectionParametersString = Proj4Projection.GetDecimalDegreesParametersString();
            wgs84ToMercatorProjection.ExternalProjectionParametersString = Proj4Projection.GetSphericalMercatorParametersString();

            //  Create a ShapeFileFeatureLayer by a shapefile.
            ShapeFileFeatureLayer restrictedLayer = new ShapeFileFeatureLayer(@"..\..\App_Data\CityLimitPolygon.shp");

            //  Set comtom styles, they will be uesed when draw the area. The priority of custom style is higher than default's.
            restrictedLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(new AreaStyle(new GeoPen(GeoColor.SimpleColors.White, 5.5f), new GeoSolidBrush(GeoColor.SimpleColors.Transparent)));
            restrictedLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(new AreaStyle(new GeoPen(GeoColor.SimpleColors.Red, 1.5f) { DashStyle = LineDashStyle.Dash }, new GeoSolidBrush(GeoColor.SimpleColors.Transparent)));
            restrictedLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            //  Set the projection of the features.
            restrictedLayer.FeatureSource.Projection = wgs84ToMercatorProjection;

            //  Add the layer to the layeroverlay.
            layerOverlay.Layers.Add(restrictedLayer);

            //  Create schools feature layer by Schools.shp.
            ShapeFileFeatureLayer schoolsFeatureLayer = new ShapeFileFeatureLayer(@"..\..\App_Data\POIs\Schools.shp");

            //  Set the default point style which determines how to display the point.
            schoolsFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = new PointStyle(new GeoImage(GetImageStream("school.png")));
            schoolsFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            schoolsFeatureLayer.FeatureSource.Projection = wgs84ToMercatorProjection;
            layerOverlay.Layers.Add(schoolsFeatureLayer);

            ShapeFileFeatureLayer hospitalsFeatureLayer = new ShapeFileFeatureLayer(@"..\..\App_Data\POIs\Medical_Facilities.shp");
            hospitalsFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = new PointStyle(new GeoImage(GetImageStream("medical_facility.png")));
            hospitalsFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            hospitalsFeatureLayer.FeatureSource.Projection = wgs84ToMercatorProjection;
            layerOverlay.Layers.Add(hospitalsFeatureLayer);

            ShapeFileFeatureLayer hotelsFeatureLayer = new ShapeFileFeatureLayer(@"..\..\App_Data\POIs\Hotels.shp");
            hotelsFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = new PointStyle(new GeoImage(GetImageStream("hotel.png")));
            hotelsFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            hotelsFeatureLayer.FeatureSource.Projection = wgs84ToMercatorProjection;
            layerOverlay.Layers.Add(hotelsFeatureLayer);

            return layerOverlay;
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            // Please set your own information about those parameters below.
            string applicationID = "Your ApplicationID";
            string cacheDirectory = @"c:\temp\";
            BingMapsLayer worldLayer = new BingMapsLayer(applicationID, BingMapsMapType.Road, cacheDirectory);

            wpfMap1.MapUnit = GeographyUnit.Meter;
            wpfMap1.CurrentExtent = new RectangleShape(-10000000, 10000000, 10000000, -10000000);
            LayerOverlay worldOverlay = new LayerOverlay();
            worldOverlay.Layers.Add("WorldLayer", worldLayer);

            wpfMap1.Overlays.Add("WorldOverlay", worldOverlay);
            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-118.098, 84.3, 118.098, -84.3);

            MrSidRasterLayer sidImageLayer = new MrSidRasterLayer(@"..\..\SampleData\Data\world.sid");
            sidImageLayer.UpperThreshold = double.MaxValue;
            sidImageLayer.LowerThreshold = 0;

            LayerOverlay staticOverlay = new LayerOverlay();
            staticOverlay.Layers.Add("SidImageLayer", sidImageLayer);
            wpfMap1.Overlays.Add(staticOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-126.4, 48.8, -67.0, 19.0);

            string connectString = "Data Source=192.168.0.58,1041;Initial Catalog=DatabaseName;Persist Security Info=True;User ID=username;Password=password";
            MsSql2008FeatureLayer sql2008Layer = new MsSql2008FeatureLayer(connectString, "states", "recid");
            sql2008Layer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;
            sql2008Layer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay sql2008Overlay = new LayerOverlay();
            sql2008Overlay.Layers.Add(new BackgroundLayer(new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean)));
            sql2008Overlay.Layers.Add("Sql2008Layer", sql2008Layer);
            wpfMap1.Overlays.Add("Sql2008Overlay", sql2008Overlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-126.4, 48.8, -67.0, 19.0);

            string connectString = "User ID=userid;Password=password;Data Source=192.168.0.178/orcl;";
            OracleFeatureLayer oracleLayer = new OracleFeatureLayer(connectString, "states", "recid");
            oracleLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;
            oracleLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay oracleOverlay = new LayerOverlay();
            oracleOverlay.Layers.Add(new BackgroundLayer(new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean)));
            oracleOverlay.Layers.Add("OracleLayer", oracleLayer);
            wpfMap1.Overlays.Add("OracleOverlay", oracleOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;

            wpfMap1.CurrentExtent = new RectangleShape(-126.4, 48.8, -67.0, 19.0);

            string connectString = "Server=192.168.0.235;User Id=userId;Password=password;DataBase=postgis;";
            PostgreSqlFeatureLayer postgreLayer = new PostgreSqlFeatureLayer(connectString, "new_states", "recid");
            postgreLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;
            postgreLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay postgreOverlay = new LayerOverlay();
            postgreOverlay.Layers.Add(new BackgroundLayer(new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean)));
            postgreOverlay.Layers.Add("PostgreLayer", postgreLayer);
            wpfMap1.Overlays.Add("PostgreOverlay", postgreOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-143.4, 109.3, 116.7, -76.3);
            wpfMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean);

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.RequiredColumnNames.Add("POP_CNTRY");
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            worldLayer.DrawingFeatures += new EventHandler<DrawingFeaturesEventArgs>(worldLayer_DrawingFeatures);

            LayerOverlay worldOverlay = new LayerOverlay();
            worldOverlay.Layers.Add("WorldLayer", worldLayer);
            wpfMap1.Overlays.Add("WorldOverlay", worldOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-116.18203125000002, 77.671875, 143.97421874999998, -60.4921875);

            WorldMapKitWmsWpfOverlay worldMapKitOverlay = new WorldMapKitWmsWpfOverlay();
            wpfMap1.Overlays.Add(worldMapKitOverlay);

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.SimpleColors.Transparent, GeoColor.FromArgb(100, GeoColor.SimpleColors.Green));
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay worldOverlay = new LayerOverlay();
            worldOverlay.Layers.Add("WorldLayer", worldLayer);
            wpfMap1.Overlays.Add("WorldOverlay", worldOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-155.733, 95.60, 104.42, -81.9);

            BackgroundLayer backgroundLayer = new BackgroundLayer(new GeoSolidBrush(GeoColor.GeographicColors.ShallowOcean));

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay worldOverlay = new LayerOverlay();
            worldOverlay.Layers.Add(backgroundLayer);
            worldOverlay.Layers.Add(worldLayer);
            wpfMap1.Overlays.Add(worldOverlay);

            wpfMap1.Refresh();
        }
        private void WpfMap_Loaded(object sender, RoutedEventArgs e)
        {
            wpfMap1.MapUnit = GeographyUnit.DecimalDegree;
            wpfMap1.CurrentExtent = new RectangleShape(-133.2515625, 89.2484375, 126.9046875, -88.290625);

            WorldMapKitWmsWpfOverlay worldMapKitOverlay = new WorldMapKitWmsWpfOverlay();
            wpfMap1.Overlays.Add(worldMapKitOverlay);

            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(@"..\..\SampleData\Data\Countries02.shp");
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.Country1;
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay worldOverlay = new LayerOverlay();
            worldOverlay.TileType = TileType.SingleTile;
            worldOverlay.Layers.Add("WorldLayer", worldLayer);
            wpfMap1.Overlays.Add("WorldOverlay", worldOverlay);

            wpfMap1.Refresh();
        }
Exemplo n.º 31
0
        private void TestForm_Load(object sender, EventArgs e)
        {
            winformsMap1.MapUnit       = GeographyUnit.DecimalDegree;
            winformsMap1.CurrentExtent = new RectangleShape(-95.2982, 38.9632, -95.2843, 38.955);
            winformsMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.FromArgb(255, 198, 255, 255));

            //Displays the World Map Kit as a background.
            ThinkGeo.MapSuite.DesktopEdition.WorldMapKitWmsDesktopOverlay worldMapKitDesktopOverlay = new ThinkGeo.MapSuite.DesktopEdition.WorldMapKitWmsDesktopOverlay();
            winformsMap1.Overlays.Add(worldMapKitDesktopOverlay);

            //InMemoryFeatureLayer for the two reference points en red.
            InMemoryFeatureLayer pointLayer = new InMemoryFeatureLayer();

            pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = PointStyles.CreateSimpleCircleStyle(GeoColor.StandardColors.Red, 12, GeoColor.StandardColors.Black);
            pointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            Feature feature1 = new Feature(new PointShape(-95.2949, 38.957));
            Feature feature2 = new Feature(new PointShape(-95.2883, 38.957));

            pointLayer.InternalFeatures.Add(feature1);
            pointLayer.InternalFeatures.Add(feature2);

            LayerOverlay pointOverlay = new LayerOverlay();

            pointOverlay.Layers.Add("PointLayer", pointLayer);
            winformsMap1.Overlays.Add("PointOverlay", pointOverlay);

            //--------------------------------------------------
            //Collection of PointShapes for the GPS locations.
            GPSlocations.Add(new PointShape(-95.2946, 38.9602));
            GPSlocations.Add(new PointShape(-95.2928, 38.9602));
            GPSlocations.Add(new PointShape(-95.2903, 38.9602));
            GPSlocations.Add(new PointShape(-95.2883, 38.9602));
            GPSlocations.Add(new PointShape(-95.2883, 38.9587));
            GPSlocations.Add(new PointShape(-95.2883, 38.957));
            GPSlocations.Add(new PointShape(-95.2897, 38.957));
            GPSlocations.Add(new PointShape(-95.2918, 38.957));
            GPSlocations.Add(new PointShape(-95.2934, 38.957));
            GPSlocations.Add(new PointShape(-95.2947, 38.957));
            GPSlocations.Add(new PointShape(-95.2946, 38.9582));
            GPSlocations.Add(new PointShape(-95.2946, 38.9593));

            InMemoryFeatureLayer vehicleLayer = new InMemoryFeatureLayer();

            vehicleLayer.Open();
            vehicleLayer.Columns.Add(new FeatureSourceColumn("DETECT", "string", 3));
            vehicleLayer.Close();

            // Draw features based on values
            ValueStyle valueStyle = new ValueStyle();

            valueStyle.ColumnName = "DETECT";
            valueStyle.ValueItems.Add(new ValueItem("No", new PointStyle(new GeoImage(@"..\..\Data\Top.png"))));
            valueStyle.ValueItems.Add(new ValueItem("yes", new PointStyle(new GeoImage(@"..\..\Data\Top2.png"))));
            vehicleLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(valueStyle);
            vehicleLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            Feature GPSfeature = new Feature(GPSlocations[0]);

            GPSfeature.ColumnValues.Add("DETECT", "No");
            vehicleLayer.InternalFeatures.Add("GPSFeature1", GPSfeature);

            LayerOverlay vehicleOverlay = new LayerOverlay();

            vehicleOverlay.Layers.Add("VehicleLayer", vehicleLayer);
            winformsMap1.Overlays.Add("VehicleOverlay", vehicleOverlay);

            //Sets timer properties
            timer.Interval = 1500;
            timer.Tick    += new EventHandler(timer_Tick);

            winformsMap1.Refresh();

            timer.Start();
        }
Exemplo n.º 32
0
        private void VisibilityChanged(bool value)
        {
            if (ConcreteObject is LayerOverlay && needRefresh)
            {
                foreach (var subEntity in Children)
                {
                    subEntity.needRefresh = false;
                    LayerPlugin layerPlugin = GisEditor.LayerManager.GetLayerPlugins(subEntity.ConcreteObject.GetType()).FirstOrDefault();
                    if (layerPlugin != null)
                    {
                        bool isDataSourceAvailable = layerPlugin.DataSourceResolveTool.IsDataSourceAvailable((Layer)subEntity.ConcreteObject);
                        if (isDataSourceAvailable)
                        {
                            subEntity.IsChecked = IsChecked;
                            ((Layer)subEntity.ConcreteObject).IsVisible = IsChecked;
                        }
                    }
                    subEntity.needRefresh = true;
                }
                var tileOverlay = (TileOverlay)ConcreteObject;
                tileOverlay.IsVisible = isChecked;
                if (!isChecked)
                {
                    RefreshOverlay(tileOverlay);
                }
                GisEditor.UIManager.InvokeRefreshPlugins();
            }
            else if (ConcreteObject is Layer && needRefresh)
            {
                LayerPlugin layerPlugin = GisEditor.LayerManager.GetLayerPlugins(ConcreteObject.GetType()).FirstOrDefault();
                if (layerPlugin != null)
                {
                    bool isDataSourceAvailable = layerPlugin.DataSourceResolveTool.IsDataSourceAvailable((Layer)ConcreteObject);
                    if (!isDataSourceAvailable)
                    {
                        ((Layer)ConcreteObject).IsVisible = false;
                        isChecked = false;
                        OnPropertyChanged("IsChecked");
                        return;
                    }
                }

                if (!isChecked)
                {
                    Image image = warningImages.FirstOrDefault(i => i.Name.Equals("InEditing", StringComparison.InvariantCultureIgnoreCase));
                    if (image != null)
                    {
                        warningImages.Remove(image);
                    }
                }
                ((Layer)ConcreteObject).IsVisible = isChecked;
                Parent.needRefresh = false;
                Parent.IsChecked   = Parent.Children.Any(m => m.IsChecked);
                Parent.needRefresh = true;
                TileOverlay tileOverlay = Parent.ConcreteObject as TileOverlay;
                if (tileOverlay != null)
                {
                    //In this case, tileOverlay will execute Refresh() in default.
                    if (!tileOverlay.IsVisible && Parent.IsChecked)
                    {
                        tileOverlay.IsVisible = Parent.IsChecked;
                    }
                    else
                    {
                        tileOverlay.IsVisible = Parent.IsChecked;
                        tileOverlay.Invalidate();
                        RefreshOverlay(tileOverlay);
                    }
                }
                GisEditor.UIManager.InvokeRefreshPlugins();
            }

            if (!(ConcreteObject is Layer) && !(ConcreteObject is LayerOverlay))
            {
                TryChangeIsVisiblePropertyOfMapElement();
            }

            if (ConcreteObject is Styles.Style)
            {
                Styles.Style concreteStyle = (Styles.Style)ConcreteObject;
                concreteStyle.IsActive = value;
                Layer layer = LayerListHelper.FindMapElementInTree <Layer>(this);
                if (layer != null && layer.IsVisible)
                {
                    LayerOverlay layerOverlay = LayerListHelper.FindMapElementInTree <LayerOverlay>(this);
                    if (layerOverlay != null && layerOverlay.IsVisible)
                    {
                        layerOverlay.Invalidate();
                        RefreshOverlay(layerOverlay);
                    }
                }
            }
        }
Exemplo n.º 33
0
        //private void SetupAnimationForOverlay(LayerOverlay overlay)
        //{
        //    overlay.Drawing -= overlay_Drawing;
        //    overlay.Drawing += overlay_Drawing;
        //    overlay.Drawn -= overlay_Drawn;
        //    overlay.Drawn += overlay_Drawn;
        //}

        private void WpfMap_MapClick(object sender, MapClickMapViewEventArgs e)
        {
            if (isIdentify)
            {
                PointShape point = e.WorldLocation;
                if (!map.Overlays.Contains(chartsOverlayName))
                {
                    return;
                }
                LayerOverlay overlay = map.Overlays[chartsOverlayName] as LayerOverlay;

                var features = new Collection <Feature>();
                NauticalChartsFeatureLayer hydrographyFeatureLayer = null;
                foreach (var item in overlay.Layers)
                {
                    NauticalChartsFeatureLayer itemLayer = item as NauticalChartsFeatureLayer;
                    itemLayer.Open();
                    features = itemLayer.QueryTools.GetFeaturesIntersecting(point.GetBoundingBox(), ReturningColumnsType.AllColumns);

                    if (features.Count > 0)
                    {
                        hydrographyFeatureLayer = itemLayer;
                        break;
                    }
                }

                if (features.Count > 0)
                {
                    List <FeatureInfo> selectedFeatures = new List <FeatureInfo>();

                    foreach (var item in features)
                    {
                        double       area      = double.MaxValue;
                        PolygonShape areaShape = item.GetShape() as PolygonShape;
                        if (areaShape != null)
                        {
                            area = areaShape.GetArea(map.MapUnit, AreaUnit.SquareMeters);
                        }
                        selectedFeatures.Add(new FeatureInfo(item, hydrographyFeatureLayer.Name, area));
                    }

                    if (map.Overlays.Contains(highlightOverlayName))
                    {
                        map.Overlays.Remove(highlightOverlayName);
                    }

                    IEnumerable <FeatureInfo> featureInfos = selectedFeatures.OrderBy(p => p.Area);
                    SelectedFeatureInfo = featureInfos.FirstOrDefault();
                    NauticalChartsFeatureSource featureSource = hydrographyFeatureLayer.FeatureSource as NauticalChartsFeatureSource;
                    if (featureSource != null)
                    {
                        ChartSelectedItem = new ChartSelectedItem(featureSource.FilePath, featureInfos);
                    }
                }
                else
                {
                    if (map.Overlays.Contains(highlightOverlayName))
                    {
                        map.Overlays.Remove(highlightOverlayName);
                    }
                    map.Refresh();
                }
            }
        }
Exemplo n.º 34
0
        void timer_Tick(object sender, EventArgs e)
        {
            //Gets the GPS info from the textfile.
            DataTable carData = GetCarData();

            double               angle;
            LayerOverlay         vehicleOverlay = (LayerOverlay)winformsMap1.Overlays["VehicleOverlay"];
            InMemoryFeatureLayer carLayer       = vehicleOverlay.Layers["CarLayer"] as InMemoryFeatureLayer;

            PointShape pointShape = carLayer.InternalFeatures[0].GetShape() as PointShape;

            // Get the Row of Data we are working with.
            DataRow carDataRow = carData.Rows[0];

            double Lat  = Convert.ToDouble(carDataRow["LAT"]);
            double Long = Convert.ToDouble(carDataRow["LONG"]);

            if (previousLong == 0)
            {
                previousLong = Long;
                previousLat  = Lat;
            }

            double Xdiff = previousLong - Long;
            double Ydiff = previousLat - Lat;

            //Gets the angle based on the current GPS position and the previous one to get the direction of the vehicle.
            angle = GetAngleFromTwoVertices(new Vertex(previousLong, previousLat), new Vertex(Long, Lat));

            carLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.RotationAngle = 90 - (float)angle;

            pointShape.X  = Long;
            pointShape.Y  = Lat;
            pointShape.Id = "Car";

            carLayer.Open();
            carLayer.EditTools.BeginTransaction();
            carLayer.EditTools.Update(pointShape);
            carLayer.EditTools.CommitTransaction();
            carLayer.Close();

            previousLong = Long;
            previousLat  = Lat;

            //Function to center the map to a point (the moving moving vehicle feature)if it goes outside the tolerance.
            RectangleShape toleranceRectangleShape = new RectangleShape(winformsMap1.CurrentExtent.UpperLeftPoint, winformsMap1.CurrentExtent.LowerRightPoint);

            toleranceRectangleShape.ScaleDown(60);
            if (toleranceRectangleShape.Contains(new PointShape(Long, Lat)) == false)
            {
                winformsMap1.CenterAt(new PointShape(Long, Lat));

                //Resets the RectangleShape of the tolerance layer (for displaying only)
                LayerOverlay         toleranceOverlay = (LayerOverlay)winformsMap1.Overlays["ToleranceOverlay"];
                InMemoryFeatureLayer toleranceLayer   = toleranceOverlay.Layers["ToleranceLayer"] as InMemoryFeatureLayer;

                RectangleShape newToleranceRectangleShape = new RectangleShape(winformsMap1.CurrentExtent.UpperLeftPoint, winformsMap1.CurrentExtent.LowerRightPoint);
                newToleranceRectangleShape.ScaleDown(60);
                newToleranceRectangleShape.Id = "Tolerance";

                toleranceLayer.Open();
                toleranceLayer.EditTools.BeginTransaction();
                toleranceLayer.EditTools.Update(newToleranceRectangleShape);
                toleranceLayer.EditTools.CommitTransaction();
                toleranceLayer.Close();

                winformsMap1.Refresh();
            }
            else
            {
                winformsMap1.Refresh(vehicleOverlay);
            }
        }
Exemplo n.º 35
0
        private void AndroidMap_MapDoubleTap(object sender, Android.Views.MotionEvent e)
        {
            androidMap.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear(); // necessary to reset the search selection
            androidMap.EditOverlay.EditShapesLayer.InternalFeatures.Clear();  // necessary to reset the search selection
            PointF     location = new PointF(e.GetX(), e.GetY());
            PointShape position = ExtentHelper.ToWorldCoordinate(androidMap.CurrentExtent, location.X,
                                                                 location.Y, androidMap.Width, androidMap.Height);
            var inputDialog = new AlertDialog.Builder(this);

            inputDialog.SetTitle("Choose Action");
            inputDialog.SetPositiveButton(
                "Get LR No.",
                (see, ess) =>
            {
                try
                {
                    LayerOverlay highlightOverlay = (LayerOverlay)androidMap.Overlays["cadastral"];
                    FeatureLayer highlightLayer   = (FeatureLayer)highlightOverlay.Layers["Cadastral"];

                    highlightLayer.Open();
                    Collection <Feature> selectedFeatures = highlightLayer.QueryTools.GetFeaturesContaining(position, new string[1] {
                        "Plotno_1"
                    });
                    highlightLayer.Close();

                    if (selectedFeatures.Count > 0)
                    {
                        string p = null;
                        foreach (var v in selectedFeatures)
                        {
                            p = v.ColumnValues["Plotno_1"].ToString();
                        }
                        var uri    = Android.Net.Uri.Parse("http://40.68.99.44/GeoManagerField/pages/valuationform.aspx?lrno=" + p);
                        var intent = new Intent(Intent.ActionView, uri);
                        StartActivity(intent);
                    }
                }
                catch (Exception ex)
                {
                    // do nothing
                }
            });
            inputDialog.SetNegativeButton("Get Building No.", (afk, kfa) => {
                try
                {
                    LayerOverlay highlightOverlay = (LayerOverlay)androidMap.Overlays["building"];
                    FeatureLayer highlightLayer   = (FeatureLayer)highlightOverlay.Layers["Building"];
                    highlightLayer.Open();
                    Collection <Feature> selectedFeatures = highlightLayer.QueryTools.GetFeaturesContaining(position, new string[1] {
                        "BLD_NO"
                    });
                    highlightLayer.Close();
                    if (selectedFeatures.Count > 0)
                    {
                        string p = null;
                        foreach (var v in selectedFeatures)
                        {
                            p = v.ColumnValues["BLD_NO"].ToString();
                        }
                        var uri    = Android.Net.Uri.Parse("http://40.68.99.44/GeoManagerField/pages/buildingform.aspx?bldno=" + p);
                        var intent = new Intent(Intent.ActionView, uri);
                        StartActivity(intent);
                    }
                }
                catch (Exception ex)
                {
                    //do nothing
                }
            });
            inputDialog.Show();
        }
Exemplo n.º 36
0
        private bool SaveSpatialFences(Map Map1, Collection <JsonFeature> features)
        {
            LayerOverlay         spatialFenceOverlay = (LayerOverlay)Map1.CustomOverlays["SpatialFenceOverlay"];
            InMemoryFeatureLayer spatialFenceLayer   = (InMemoryFeatureLayer)spatialFenceOverlay.Layers["SpatialFenceLayer"];

            try
            {
                spatialFenceLayer.Open();

                Collection <Feature> newAddedFeatures = new Collection <Feature>();
                foreach (JsonFeature jsonFeature in features)
                {
                    if (string.IsNullOrEmpty(jsonFeature.Id))
                    {
                        Feature feature = new Feature(jsonFeature.Wkt, Guid.NewGuid().ToString());
                        feature.ColumnValues["Restricted"] = "Restricted";
                        newAddedFeatures.Add(feature);
                    }
                }

                if (features.Count != 0 && newAddedFeatures.Count == features.Count) // if all the features are requested features, means map is under draw polygon
                {
                    // add new features to spatial fence layer
                    foreach (Feature feature in newAddedFeatures)
                    {
                        spatialFenceLayer.InternalFeatures.Add(feature);
                    }

                    // Insert new feature into the database
                    using (TrackingAccessProvider vehicleProvider = new TrackingAccessProvider(AppDomain.CurrentDomain.BaseDirectory + ConfigurationManager.AppSettings["AccessDataBase"]))
                    {
                        // Insert new added and modified features to database
                        foreach (Feature feature in newAddedFeatures)
                        {
                            vehicleProvider.InsertSpatialFence(feature);
                        }
                    }
                }
                else // Deal with modify mode is activated scenario
                {
                    Collection <Feature>             modifiedFeatures  = new Collection <Feature>();
                    Dictionary <string, JsonFeature> keyedJsonFeatures = new Dictionary <string, JsonFeature>();
                    foreach (JsonFeature jsonFeature in features)
                    {
                        if (!string.IsNullOrEmpty(jsonFeature.Id))  // If id is not null, it's the feature after editing
                        {
                            keyedJsonFeatures.Add(jsonFeature.Id, jsonFeature);
                            Feature feature = new Feature(jsonFeature.Wkt, jsonFeature.Id);
                            feature.ColumnValues["Restricted"] = "Restricted";
                            modifiedFeatures.Add(feature);
                        }
                    }

                    // Get removed features
                    Collection <Feature> removedFeatures = new Collection <Feature>();
                    foreach (Feature feature in Map1.EditOverlay.Features)
                    {
                        if (!keyedJsonFeatures.ContainsKey(feature.Id))
                        {
                            removedFeatures.Add(feature);
                        }
                    }
                    // Refine the spatial fence layer
                    spatialFenceLayer.InternalFeatures.Clear();
                    foreach (Feature feature in newAddedFeatures)
                    {
                        spatialFenceLayer.InternalFeatures.Add(feature);
                    }
                    foreach (Feature feature in modifiedFeatures)
                    {
                        spatialFenceLayer.InternalFeatures.Add(feature);
                    }
                    Map1.EditOverlay.Features.Clear();
                    spatialFenceOverlay.Redraw();

                    // Update the database
                    using (TrackingAccessProvider vehicleProvider = new TrackingAccessProvider(AppDomain.CurrentDomain.BaseDirectory + ConfigurationManager.AppSettings["AccessDataBase"]))
                    {
                        // Delete all spatial fences from database and then update the existing ones
                        if (removedFeatures.Count > 0)
                        {
                            vehicleProvider.DeleteSpatialFences(removedFeatures);
                        }
                        // Insert new added and modified features to database
                        foreach (Feature feature in newAddedFeatures)
                        {
                            vehicleProvider.InsertSpatialFence(feature);
                        }
                        foreach (Feature feature in modifiedFeatures)
                        {
                            vehicleProvider.UpdateSpatialFenceByFeature(feature);
                        }
                    }
                }
                return(true);
            }
            catch
            {
                return(false);
            }
        }
Exemplo n.º 37
0
        private void HandleLoadChartMessage(ChartMessage message)
        {
            LayerOverlay overlay = null;

            if (message.Charts != null)
            {
                if (map.Overlays.Contains(chartsOverlayName))
                {
                    overlay = ((LayerOverlay)map.Overlays[chartsOverlayName]);
                }
                else
                {
                    overlay = new LayerOverlay()
                    {
                        TileType = TileType.SingleTile,
                    };
                    map.Overlays.Insert(1, chartsOverlayName, overlay);
                }

                overlay.Layers.Clear();
                ChartSelectedItem = new ChartSelectedItem(string.Empty, null);
                IEnumerable <ChartItem> charts      = message.Charts;
                RectangleShape          boundingBox = null;
                foreach (ChartItem item in charts)
                {
                    if (!File.Exists(item.IndexFileName))
                    {
                        NauticalChartsFeatureSource.BuildIndexFile(item.FileName, BuildIndexMode.DoNotRebuild);
                    }
                    NauticalChartsFeatureLayer layer = new NauticalChartsFeatureLayer(item.FileName);
                    if (map.MapUnit == GeographyUnit.Meter)
                    {
                        layer.FeatureSource.ProjectionConverter = new ProjectionConverter(4326, 3857);
                    }

                    layer.DrawingFeatures += hydrographyLayer_DrawingFeatures;

                    layer.IsDepthContourTextVisible = Globals.IsDepthContourTextVisible;
                    layer.IsLightDescriptionVisible = Globals.IsLightDescriptionVisible;
                    layer.IsSoundingTextVisible     = Globals.IsSoundingTextVisible;
                    layer.SymbolTextDisplayMode     = Globals.SymbolTextDisplayMode;
                    layer.DisplayCategory           = Globals.DisplayMode;
                    layer.DefaultColorSchema        = Globals.CurrentColorSchema;
                    layer.SymbolDisplayMode         = Globals.CurrentSymbolDisplayMode;
                    layer.BoundaryDisplayMode       = Globals.CurrentBoundaryDisplayMode;

                    layer.SafetyDepthInMeter        = NauticalChartsFeatureLayer.ConvertDistanceToMeters(Globals.SafetyDepth, Globals.CurrentDepthUnit);
                    layer.ShallowDepthInMeter       = NauticalChartsFeatureLayer.ConvertDistanceToMeters(Globals.ShallowDepth, Globals.CurrentDepthUnit);
                    layer.DeepDepthInMeter          = NauticalChartsFeatureLayer.ConvertDistanceToMeters(Globals.DeepDepth, Globals.CurrentDepthUnit);
                    layer.SafetyContourDepthInMeter = NauticalChartsFeatureLayer.ConvertDistanceToMeters(Globals.SafetyContour, Globals.CurrentDepthUnit);

                    layer.DrawingMode            = Globals.CurrentDrawingMode;
                    layer.IsFullLightLineVisible = Globals.IsFullLightLineVisible;
                    layer.IsMetaObjectsVisible   = Globals.IsMetaObjectsVisible;
                    layer.Name = item.FileName;
                    layer.Open();
                    if (boundingBox == null)
                    {
                        boundingBox = layer.GetBoundingBox();
                    }
                    else
                    {
                        boundingBox.ExpandToInclude(layer.GetBoundingBox());
                    }

                    boundingBoxPreviewLayer.InternalFeatures.Add(layer.GetHashCode().ToString(), new Feature(layer.GetBoundingBox()));

                    layer.Close();
                    overlay.Layers.Add(item.FileName, layer);
                }
                if (boundingBox != null)
                {
                    map.CurrentExtent = boundingBox;
                }

                //SetupAnimationForOverlay(overlay);

                ApplyOverlayOpacity();

                map.Refresh();
            }
        }
Exemplo n.º 38
0
        /// <summary>
        /// Show the POI overlay
        /// </summary>
        private void ShowPoiGroup_Checked(object sender, EventArgs e)
        {
            LayerOverlay poiOverlay = (LayerOverlay)mapView.Overlays["poiOverlay"];

            poiOverlay.IsVisible = ShowPoi.IsChecked;
        }
Exemplo n.º 39
0
        /// <summary>
        /// Show the Landuse overlay
        /// </summary>
        private void ShowLanduseGroup_Checked(object sender, EventArgs e)
        {
            LayerOverlay landuseOverlay = (LayerOverlay)mapView.Overlays["landuseOverlay"];

            landuseOverlay.IsVisible = ShowLandUse.IsChecked;
        }
Exemplo n.º 40
0
        private void MainForm_Loaded(object sender, RoutedEventArgs e)
        {
            // set map properties
            Map.MinimumScale = 0;
            Map.MapUnit      = GeographyUnit.DecimalDegree;
            Map.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.StandardColors.AliceBlue);
            Map.MapTools.Logo.IsEnabled           = false;

            // create source overlay and layer style
            var sourceOverlay = new LayerOverlay()
            {
                TileType       = TileType.SingleTile,
                DrawingQuality = DrawingQuality.HighSpeed
            };

            var layerStyle = new ValueStyle("State", new Collection <ValueItem>()
            {
                new ValueItem("0", new AreaStyle(GeoPens.Black, GeoBrushes.Green)),
                new ValueItem("1", new AreaStyle(GeoPens.Black, GeoBrushes.Yellow)),
                new ValueItem("2", new AreaStyle(GeoPens.Black, GeoBrushes.Red)),
                new ValueItem("3", new AreaStyle(GeoPens.Black, GeoBrushes.Orange))
            });

            for (int layerIndex = 0; layerIndex < layerCount; layerIndex++)
            {
                // create source layer
                var sourceLayer = new InMemoryFeatureLayer()
                {
                    Name = $"Source Layer #{layerIndex}"
                };
                sourceLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(layerStyle);
                sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

                // add rectangle shape features to source layer, calculate position and size of each rectangle shapes
                double featureInterval = 1.0;
                double featureSize     = 1.0;
                for (int row = 0; row < featureRowCount; row++)
                {
                    for (int column = 0; column < featureColumnCount; column++)
                    {
                        double upperLeftX = column * (featureSize + featureInterval);
                        double upperLeftY = (layerIndex * featureRowCount + row) * (featureSize + featureInterval);
                        var    feature    = new Feature(new PolygonShape(new RingShape(new Collection <Vertex>()
                        {
                            new Vertex(upperLeftX, upperLeftY),
                            new Vertex(upperLeftX, upperLeftY + featureSize),
                            new Vertex(upperLeftX + featureSize, upperLeftY + featureSize),
                            new Vertex(upperLeftX + featureSize, upperLeftY)
                        })))
                        {
                            Id = $"{column}.{row}"
                        };
                        feature.ColumnValues.Add("State", "0");
                        sourceLayer.InternalFeatures.Add(feature.Id, feature);
                    }
                }

                sourceOverlay.Layers.Add(sourceLayer);
                Layers.Add(sourceLayer);
            }

            // refresh the map
            Map.Overlays.Add("SourceOverlay", sourceOverlay);
            Map.CurrentExtent = sourceOverlay.GetBoundingBox();
            Map.Refresh();
        }
Exemplo n.º 41
0
        /// <summary>
        /// Setup the map with the ThinkGeo Cloud Maps overlay. Also, load landuse and POI layers into a grouped LayerOverlay and display them on the map.
        /// </summary>
        protected override void OnAppearing()
        {
            base.OnAppearing();
            // Set the map's unit of measurement to meters(Spherical Mercator)
            mapView.MapUnit = GeographyUnit.Meter;

            // Add Cloud Maps as a background overlay
            var thinkGeoCloudVectorMapsOverlay = new ThinkGeoCloudVectorMapsOverlay("9ap16imkD_V7fsvDW9I8r8ULxgAB50BX_BnafMEBcKg~", "vtVao9zAcOj00UlGcK7U-efLANfeJKzlPuDB9nw7Bp4K4UxU_PdRDg~~", ThinkGeoCloudVectorMapsMapType.Light);

            thinkGeoCloudVectorMapsOverlay.VectorTileCache = new FileVectorTileCache(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "cache"), "CloudMapsVector");
            mapView.Overlays.Add(thinkGeoCloudVectorMapsOverlay);

            //**********************
            // * Landuse LayerOverlay
            // **********************/

            // Create cityLimits layer
            var cityLimits = new ShapeFileFeatureLayer(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Data/Shapefile/FriscoCityLimits.shp"));

            // Style cityLimits layer
            cityLimits.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle    = AreaStyle.CreateSimpleAreaStyle(GeoColors.Transparent, GeoColors.DimGray, 2);
            cityLimits.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            // Project cityLimits layer to Spherical Mercator to match the map projection
            cityLimits.FeatureSource.ProjectionConverter = new ProjectionConverter(2276, 3857);

            LayerOverlay poiOverlay     = new LayerOverlay();
            LayerOverlay landuseOverlay = new LayerOverlay();

            // Add cityLimits layer to the landuseGroup overlay
            landuseOverlay.Layers.Add(cityLimits);

            // Create Parks landuse layer
            var parks = new ShapeFileFeatureLayer(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Data/Shapefile/Parks.shp"));

            // Style Parks landuse layer
            parks.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle    = AreaStyle.CreateSimpleAreaStyle(new GeoColor(128, GeoColors.Green), GeoColors.Transparent);
            parks.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            // Project Parks landuse layer to Spherical Mercator to match the map projection
            parks.FeatureSource.ProjectionConverter = new ProjectionConverter(2276, 3857);

            // Add Parks landuse layer to the landuseGroup overlay
            landuseOverlay.Layers.Add(parks);

            // Add Landuse overlay to the map
            mapView.Overlays.Add("landuseOverlay", landuseOverlay);

            //******************
            // * POI LayerOverlay
            // ******************/

            // Create Hotel POI layer
            var hotels = new ShapeFileFeatureLayer(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Data/Shapefile/Hotels.shp"));

            // Style Hotel POI layer
            hotels.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = PointStyle.CreateSimpleCircleStyle(GeoColors.Blue, 8, GeoColors.White, 2);
            hotels.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            // Project Hotels POI layer to Spherical Mercator to match the map projection
            hotels.FeatureSource.ProjectionConverter = new ProjectionConverter(2276, 3857);

            // Add Hotel POI layer to the poiGroup overlay
            poiOverlay.Layers.Add(hotels);

            // Create School POI layer
            var schools = new ShapeFileFeatureLayer(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Data/Shapefile/Schools.shp"));

            // Style School POI layer
            schools.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = PointStyle.CreateSimpleCircleStyle(GeoColors.Red, 8, GeoColors.White, 2);
            schools.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            // Project Schools POI layer to Spherical Mercator to match the map projection
            schools.FeatureSource.ProjectionConverter = new ProjectionConverter(2276, 3857);

            // Add School POI layer to the poiGroup overlay
            poiOverlay.Layers.Add(schools);

            // Add POI overlay to the map
            mapView.Overlays.Add("poiOverlay", poiOverlay);

            // Set the map extent
            cityLimits.Open();
            mapView.CurrentExtent = cityLimits.GetBoundingBox();
            cityLimits.Close();

            ShowPoi.IsChecked     = true;
            ShowLandUse.IsChecked = true;

            mapView.Refresh();
        }
Exemplo n.º 42
0
        private void TestForm_Load(object sender, EventArgs e)
        {
            winformsMap1.MapUnit = GeographyUnit.DecimalDegree;
            winformsMap1.CurrentExtent = new RectangleShape(-120,86,112,-54);
            winformsMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.FromArgb(255, 198, 255, 255));

            //Layer for simply displaying countries as a simple area style.
            ShapeFileFeatureLayer worldShapeLayer = new ShapeFileFeatureLayer(@"..\..\Data\Countries02.shp");
            worldShapeLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.StandardColors.LightGoldenrodYellow, GeoColor.FromArgb(100, GeoColor.SimpleColors.Green));
            worldShapeLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            //Layer for displaying the country labels using ClassBreakStyle to have the label size proportinal to the country size.
            ShapeFileFeatureLayer worldLabelLayer = new ShapeFileFeatureLayer(@"..\..\Data\Countries02.shp");
            
            //For Zoom Levels 01 to 03, displays the country labels for countries above 500,000 sqkm in area with two classes.
            ClassBreakStyle classBreakStyle1 = new ClassBreakStyle("SQKM");
            TextStyle textStyle1a = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 9, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 2, 0, 0);
            TextStyle textStyle1b = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 12, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 3, 0, 0);
            classBreakStyle1.ClassBreaks.Add(new ClassBreak(500000, textStyle1a));
            classBreakStyle1.ClassBreaks.Add(new ClassBreak(5000000, textStyle1b));
            worldLabelLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(classBreakStyle1);
            worldLabelLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level03;

            //For Zoom Levels 04 to 05, displays the country labels for countries above 100,000 sqkm in area with three classes.
            ClassBreakStyle classBreakStyle2 = new ClassBreakStyle("SQKM");
            TextStyle textStyle2a = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 9, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 2, 0, 0);
            TextStyle textStyle2b = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 11, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 2, 0, 0);
            TextStyle textStyle2c = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 14, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 3, 0, 0);
            classBreakStyle2.ClassBreaks.Add(new ClassBreak(100000, textStyle2a));
            classBreakStyle2.ClassBreaks.Add(new ClassBreak(500000, textStyle2b));
            classBreakStyle2.ClassBreaks.Add(new ClassBreak(3000000, textStyle2c));
            worldLabelLayer.ZoomLevelSet.ZoomLevel04.CustomStyles.Add(classBreakStyle2);
            worldLabelLayer.ZoomLevelSet.ZoomLevel04.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level05;

            //For Zoom Levels 06 to 07, displays the country labels for countries above 20,000 sqkm in area with four classes.
            ClassBreakStyle classBreakStyle3 = new ClassBreakStyle("SQKM");
            TextStyle textStyle3a = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 9, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 2, 0, 0);
            TextStyle textStyle3b = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 12, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 2, 0, 0);
            TextStyle textStyle3c = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 14, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 2, 0, 0);
            TextStyle textStyle3d = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 18, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 3, 0, 0);
            classBreakStyle3.ClassBreaks.Add(new ClassBreak(20000, textStyle3a));
            classBreakStyle3.ClassBreaks.Add(new ClassBreak(100000, textStyle3b));
            classBreakStyle3.ClassBreaks.Add(new ClassBreak(500000, textStyle3c));
            classBreakStyle3.ClassBreaks.Add(new ClassBreak(3000000, textStyle3d));
            worldLabelLayer.ZoomLevelSet.ZoomLevel06.CustomStyles.Add(classBreakStyle3);
            worldLabelLayer.ZoomLevelSet.ZoomLevel06.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level07;

            //For Zoom Levels 08 to 20, displays the country labels for all countries with five classes.
            ClassBreakStyle classBreakStyle4 = new ClassBreakStyle("SQKM");
            TextStyle textStyle4a = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 9, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 2, 0, 0);
            TextStyle textStyle4b = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 12, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 2, 0, 0);
            TextStyle textStyle4c = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 14, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 2, 0, 0);
            TextStyle textStyle4d = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 18, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 2, 0, 0);
            TextStyle textStyle4e = TextStyles.CreateSimpleTextStyle("CNTRY_NAME", "Arial", 22, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 3, 0, 0);
            classBreakStyle4.ClassBreaks.Add(new ClassBreak(0, textStyle4a));
            classBreakStyle4.ClassBreaks.Add(new ClassBreak(20000, textStyle4b));
            classBreakStyle4.ClassBreaks.Add(new ClassBreak(100000, textStyle4c));
            classBreakStyle4.ClassBreaks.Add(new ClassBreak(500000, textStyle4d));
            classBreakStyle4.ClassBreaks.Add(new ClassBreak(3000000, textStyle4e));
            worldLabelLayer.ZoomLevelSet.ZoomLevel08.CustomStyles.Add(classBreakStyle4);
            worldLabelLayer.ZoomLevelSet.ZoomLevel08.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
           
            LayerOverlay staticOverlay = new LayerOverlay();
            staticOverlay.Layers.Add("WorldShapeLayer", worldShapeLayer);
            staticOverlay.Layers.Add("WorldLabelLayer", worldLabelLayer);
            winformsMap1.Overlays.Add(staticOverlay);

            winformsMap1.Refresh();
        }
Exemplo n.º 43
0
        /// <summary>
        /// Set up the map with the ThinkGeo Cloud Maps overlay and a feature layer containing Frisco hotels data
        /// </summary>
        protected override void OnAppearing()
        {
            base.OnAppearing();
            // Create the background world maps using vector tiles requested from the ThinkGeo Cloud Service.
            ThinkGeoCloudVectorMapsOverlay thinkGeoCloudVectorMapsOverlay = new ThinkGeoCloudVectorMapsOverlay("9ap16imkD_V7fsvDW9I8r8ULxgAB50BX_BnafMEBcKg~", "vtVao9zAcOj00UlGcK7U-efLANfeJKzlPuDB9nw7Bp4K4UxU_PdRDg~~", ThinkGeoCloudVectorMapsMapType.Light);

            thinkGeoCloudVectorMapsOverlay.VectorTileCache = new FileVectorTileCache(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "cache"), "CloudMapsVector");

            mapView.Overlays.Add(thinkGeoCloudVectorMapsOverlay);

            // Set the Map Unit to meters (used in Spherical Mercator)
            mapView.MapUnit = GeographyUnit.Meter;

            // Create a feature layer to hold the Frisco hotels data
            ShapeFileFeatureLayer hotelsLayer = new ShapeFileFeatureLayer(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Data/Shapefile/Hotels.shp"));

            // Convert the Frisco shapefile from its native projection to Spherical Mercator, to match the map
            ProjectionConverter projectionConverter = new ProjectionConverter(2276, 3857);

            hotelsLayer.FeatureSource.ProjectionConverter = projectionConverter;

            // Add a style to use to draw the Frisco hotel points
            hotelsLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            hotelsLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = new PointStyle(PointSymbolType.Star, 24, GeoBrushes.MediumPurple, GeoPens.Purple);

            InMemoryFeatureLayer highlightedHotelLayer = new InMemoryFeatureLayer();

            highlightedHotelLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            highlightedHotelLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = new PointStyle(PointSymbolType.Star, 30, GeoBrushes.BrightYellow, GeoPens.Black);

            // Add the feature layer to an overlay, and add the overlay to the map
            LayerOverlay layerOverlay = new LayerOverlay();

            layerOverlay.Layers.Add("Frisco Hotels", hotelsLayer);
            layerOverlay.Layers.Add("Highlighted Hotel", highlightedHotelLayer);
            mapView.Overlays.Add(layerOverlay);

            // Open the hotels layer so we can read the data from it
            hotelsLayer.Open();

            // Get all features from the hotels layer
            // ReturningColumnsType.AllColumns will return all attributes for the features
            var features = hotelsLayer.QueryTools.GetAllFeatures(ReturningColumnsType.AllColumns);

            // Create a collection of Hotel objects to use as the data source for our list box
            Collection <Hotel> hotels = new Collection <Hotel>();

            // Create a hotel object based on the data from each hotel feature, and add them to the collection
            foreach (Feature feature in features)
            {
                string     name     = feature.ColumnValues["NAME"];
                string     address  = feature.ColumnValues["ADDRESS"];
                int        rooms    = int.Parse(feature.ColumnValues["ROOMS"]);
                PointShape location = (PointShape)feature.GetShape();

                hotels.Add(new Hotel(name, address, rooms, location));
            }

            // Set the hotel collection as the data source of the list box
            lsbHotels.ItemsSource = hotels;

            // Set the map extent to the extent of the hotel features
            mapView.CurrentExtent = hotelsLayer.GetBoundingBox();
            hotelsLayer.Close();

            // Refresh and redraw the map
            mapView.Refresh();
        }
Exemplo n.º 44
0
        private void TestForm_Load(object sender, EventArgs e)
        {
            winformsMap1.MapUnit = GeographyUnit.DecimalDegree;
            winformsMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.StandardColors.LightGoldenrodYellow);

            //Scale bar to have a graphic representation of the scale
            ScaleBarAdornmentLayer scaleBar = new ScaleBarAdornmentLayer();

            scaleBar.UnitFamily = UnitSystem.Metric;
            scaleBar.Location   = AdornmentLocation.LowerLeft;
            winformsMap1.AdornmentOverlay.Layers.Add(scaleBar);

            //Snapping mode to none so that we can set and get the exact scale without snapping the map.
            winformsMap1.ZoomLevelSnapping = ZoomLevelSnappingMode.None;

            //Set of 10 zoom levels from 1:200,00 to 1:250 the zoom level below being half in scale compare to the previous zoom level.
            //Notice that the scale parameter for ZoomLevel is the middle scale for that zoom level. The range of scale for the zoom level
            //will be based on the scale values of the zoom level below and above.
            //As an academic reminder, the scale means the ratio on the map to the corresponding distance on the ground. So, a scale of 1:100,000
            //means that one unit (for example one centimeter) on the map represents 100,000 units ( or 100,000 centimeters or 1 kilometers on the ground).

            ZoomLevelSet partitionedZoomLevelSet = new ZoomLevelSet();

            partitionedZoomLevelSet.CustomZoomLevels.Add(new ZoomLevel(200000)); //Zoom Level 1  1:200,000 (beyond 1:150,000)
            partitionedZoomLevelSet.CustomZoomLevels.Add(new ZoomLevel(100000)); //Zoom Level 2  1:100,000 (from 1:75,000 to 1:150,000)
            partitionedZoomLevelSet.CustomZoomLevels.Add(new ZoomLevel(50000));  //Zoom Level 3  1: 50,000 (from 1:37,000 to 1:75,000)
            partitionedZoomLevelSet.CustomZoomLevels.Add(new ZoomLevel(25000));  //Zoom Level 4  1: 25,000 (from 1:17,000 to 1:37,500)
            partitionedZoomLevelSet.CustomZoomLevels.Add(new ZoomLevel(10000));  //Zoom Level 5  1: 10,000 (from 1:7,500 to 1:17,500)
            partitionedZoomLevelSet.CustomZoomLevels.Add(new ZoomLevel(5000));   //Zoom Level 6  1:  5,000 (from 1:3,750 to 1:7,500)
            partitionedZoomLevelSet.CustomZoomLevels.Add(new ZoomLevel(2500));   //Zoom Level 7  1:  2,500 (from 1:1,750 to 1:3,750)
            partitionedZoomLevelSet.CustomZoomLevels.Add(new ZoomLevel(1000));   //Zoom Level 8  1:  1,000 (from 1:750 to 1:1,750)
            partitionedZoomLevelSet.CustomZoomLevels.Add(new ZoomLevel(500));    //Zoom Level 9  1:    500 (from 1:375 to 1:750)
            partitionedZoomLevelSet.CustomZoomLevels.Add(new ZoomLevel(250));    //Zoom Level 10 1:    250 (below 1:375)
            winformsMap1.ZoomLevelSet = partitionedZoomLevelSet;


            //Uses the Name property of ZoomLevel to give the characteristics such as the scale range.
            Collection <ZoomLevel> zoomLevels = winformsMap1.ZoomLevelSet.GetZoomLevels();

            for (int i = 0; i < zoomLevels.Count; i++)
            {
                string ScaleRange;
                double BottomScale, TopScale;
                if (i == 0)
                {
                    BottomScale = zoomLevels[i + 1].Scale + ((zoomLevels[i].Scale - zoomLevels[i + 1].Scale) / 2);
                    ScaleRange  = "Beyond 1: " + String.Format("{0:0,0}", BottomScale);
                }
                else if (i < zoomLevels.Count - 1)
                {
                    BottomScale = zoomLevels[i + 1].Scale + ((zoomLevels[i].Scale - zoomLevels[i + 1].Scale) / 2);
                    TopScale    = zoomLevels[i].Scale + ((zoomLevels[i - 1].Scale - zoomLevels[i].Scale) / 2);
                    ScaleRange  = "From 1: " + String.Format("{0:0,0}", BottomScale) + " to 1: " + String.Format("{0:0,0}", TopScale);
                }
                else
                {
                    TopScale   = zoomLevels[i].Scale + ((zoomLevels[i - 1].Scale - zoomLevels[i].Scale) / 2);
                    ScaleRange = "Below 1: " + String.Format("{0:0,0}", TopScale);
                }


                zoomLevels[i].Name = "Zoom Level " + (i + 1).ToString() + "                        " + ScaleRange;
            }


            ShapeFileFeatureLayer layer1 = new ShapeFileFeatureLayer(@"..\..\Data\Austinstreets.shp");

            //Sets the custom Zoom levels to ZoomLevelSet
            layer1.ZoomLevelSet = partitionedZoomLevelSet;
            //Set a different style at each zoom level to help distinguish when we change zoom level when zooming in and out on the map.
            layer1.ZoomLevelSet.CustomZoomLevels[0].DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.Red, 2, true);
            layer1.ZoomLevelSet.CustomZoomLevels[1].DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.Green, 2, true);
            layer1.ZoomLevelSet.CustomZoomLevels[2].DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.Pink, 2, true);
            layer1.ZoomLevelSet.CustomZoomLevels[3].DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.Blue, 2, true);
            layer1.ZoomLevelSet.CustomZoomLevels[4].DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.Orange, 2, true);
            layer1.ZoomLevelSet.CustomZoomLevels[5].DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.Turquoise, 2, true);
            layer1.ZoomLevelSet.CustomZoomLevels[6].DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.Violet, 2, true);
            layer1.ZoomLevelSet.CustomZoomLevels[7].DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.YellowGreen, 2, true);
            layer1.ZoomLevelSet.CustomZoomLevels[8].DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.Brown, 2, true);
            layer1.ZoomLevelSet.CustomZoomLevels[9].DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.DarkGreen, 2, true);

            LayerOverlay layerOverlay = new LayerOverlay();

            layerOverlay.Layers.Add(layer1);
            winformsMap1.Overlays.Add(layerOverlay);

            layer1.Open();
            winformsMap1.CurrentExtent = layer1.GetBoundingBox();
            layer1.Close();

            winformsMap1.Refresh();

            lblZoom.Text = winformsMap1.ZoomLevelSet.GetZoomLevel(winformsMap1.CurrentExtent, winformsMap1.Width, winformsMap1.MapUnit).Name;
        }
Exemplo n.º 45
0
        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);
            SetContentView(Resource.Layout.Main);

            // WorldMapKitOverlay worldOverlay = new WorldMapKitOverlay();
            androidMap = FindViewById <MapView>(Resource.Id.androidmap);
            androidMap.TrackOverlay.VertexAdded += (sender, e) => { endVertex = e.AddedVertex; };
            androidMap.MapUnit = GeographyUnit.Meter;

            ShapeFileFeatureLayer shapeFileFeatureLayer = new ShapeFileFeatureLayer(System.IO.Path.Combine(Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryDownloads).ToString(), "cadastral.shp"));

            shapeFileFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(
                GeoColor.FromArgb(100, GeoColor.StandardColors.White), GeoColor.StandardColors.Green);
            shapeFileFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle    = new TextStyle("Plotno_1", new GeoFont("Arail", 9, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));
            shapeFileFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            ShapeFileFeatureLayer buildingLayer = new ShapeFileFeatureLayer(System.IO.Path.Combine(Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryDownloads).ToString(), "building.shp"));

            buildingLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(
                GeoColor.FromArgb(100, GeoColor.StandardColors.Gray), GeoColor.StandardColors.Blue);
            buildingLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle    = new TextStyle("BLD_NO", new GeoFont("Arail", 9, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));
            buildingLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            ShapeFileFeatureLayer hLayer = new ShapeFileFeatureLayer(System.IO.Path.Combine(Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryDownloads).ToString(), "BLOCKs.shp"), ShapeFileReadWriteMode.ReadWrite);

            hLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = new TextStyle("BLOCKSch", new GeoFont("Arail", 9, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));
            hLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(100, GeoColor.StandardColors.Blue);
            hLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color     = GeoColor.StandardColors.Blue;
            hLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen             = new GeoPen(GeoColor.FromArgb(200, GeoColor.StandardColors.Red), 5);
            hLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolPen           = new GeoPen(GeoColor.FromArgb(255, GeoColor.StandardColors.Green), 8);
            hLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = PointStyles.CreateSimpleCircleStyle(GeoColor.StandardColors.Red, 12, GeoColor.StandardColors.Black);
            pointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            //  Feature gmp = new Feature(new PointShape(256721.2508062, 9855780.04717357));
            //  pointLayer.InternalFeatures.Add(gmp);
            LayerOverlay pointOverlay = new LayerOverlay( );

            pointOverlay.Layers.Add("PointLayer", pointLayer);

            //  LayerOverlay layerOverlay = new LayerOverlay();  moved to public
            layerOverlay.Layers.Add("Cadastral", shapeFileFeatureLayer);

            LayerOverlay hOverlay = new LayerOverlay();

            hOverlay.Layers.Add("Blocks", hLayer);

            LayerOverlay bOverlay = new LayerOverlay();

            bOverlay.Layers.Add("Building", buildingLayer);

            androidMap.Overlays.Add("building", bOverlay);
            androidMap.Overlays.Add("cadastral", layerOverlay);
            androidMap.Overlays.Add("blocks", hOverlay);
            androidMap.Overlays.Add("gmpoint", pointOverlay);

            //  var v = Android.OS.Environment.GetExternalStoragePublicDirectory ();
            //Internal projection string from the PRJ file. Note that the false easting value (x_0) has to be expressed in meter for proj4 string.
            string internalProjectionString = "+proj=utm +zone=37 +south +ellps=clrk80 +units=m +no_defs";

            proj4.InternalProjectionParametersString = internalProjectionString;
            //External projection string as Geodetic (21037).
            proj4.ExternalProjectionParametersString = ManagedProj4Projection.GetEpsgParametersString(21037);
            proj4.Open();

            shapeFileFeatureLayer.FeatureSource.Projection = proj4;
            buildingLayer.FeatureSource.Projection         = proj4;
            pointLayer.FeatureSource.Projection            = proj4;

            hLayer.RequireIndex                = false;
            buildingLayer.RequireIndex         = false;
            shapeFileFeatureLayer.RequireIndex = false;
            shapeFileFeatureLayer.Open();
            androidMap.MapDoubleTap += AndroidMap_MapDoubleTap;

            androidMap.CurrentExtent = shapeFileFeatureLayer.GetBoundingBox();
            shapeFileFeatureLayer.Close();
            proj4.Close();
            androidMap.Refresh();

            gpsButton       = GetButton(Resource.Drawable.Gps, TrackButtonClick);
            addButton       = GetButton(Resource.Drawable.Add, TrackButtonClick);
            searchButton    = GetButton(Resource.Drawable.Search, TrackButtonClick);
            cursorButton    = GetButton(Resource.Drawable.Cursor, TrackButtonClick);
            drawButton      = GetButton(Resource.Drawable.Draw, TrackButtonClick);
            pointButton     = GetButton(Resource.Drawable.Point, TrackButtonClick);
            lineButton      = GetButton(Resource.Drawable.Line, TrackButtonClick);
            rectangleButton = GetButton(Resource.Drawable.Rectangle, TrackButtonClick);
            circleButton    = GetButton(Resource.Drawable.Circle, TrackButtonClick);
            polygonButton   = GetButton(Resource.Drawable.Polygon, TrackButtonClick);
            ellipseButton   = GetButton(Resource.Drawable.Ellipse, TrackButtonClick);
            editButton      = GetButton(Resource.Drawable.Edit, TrackButtonClick);
            clearButton     = GetButton(Resource.Drawable.Clear, TrackButtonClick);

            trackLinearLayout             = new LinearLayout(this);
            trackLinearLayout.Orientation = Orientation.Horizontal;
            trackLinearLayout.Visibility  = ViewStates.Gone;
            trackLinearLayout.AddView(pointButton);
            trackLinearLayout.AddView(lineButton);
            trackLinearLayout.AddView(rectangleButton);
            trackLinearLayout.AddView(polygonButton);
            trackLinearLayout.AddView(ellipseButton);

            LinearLayout toolsLinearLayout = new LinearLayout(this);

            toolsLinearLayout.AddView(searchButton);
            toolsLinearLayout.AddView(addButton);
            toolsLinearLayout.AddView(gpsButton);
            toolsLinearLayout.AddView(cursorButton);
            toolsLinearLayout.AddView(drawButton);
            toolsLinearLayout.AddView(trackLinearLayout);
            toolsLinearLayout.AddView(editButton);
            toolsLinearLayout.AddView(clearButton);
            InitializeInstruction(toolsLinearLayout);
        }
        private static void MoveItem(MovementAction movementAction)
        {
            var selectedItem = GisEditor.LayerListManager.SelectedLayerListItem;

            if (selectedItem != null && selectedItem.ConcreteObject != null)
            {
                Layer   layer       = selectedItem.ConcreteObject as Layer;
                Overlay overlay     = selectedItem.ConcreteObject as Overlay;
                Style   styleItem   = selectedItem.ConcreteObject as Style;
                bool    needRefresh = false;

                if (layer != null)
                {
                    Overlay parentOverlay = GisEditor.ActiveMap.GetOverlaysContaining(layer).FirstOrDefault();
                    if (parentOverlay is LayerOverlay)
                    {
                        LayerOverlay layerOverlay = (LayerOverlay)parentOverlay;
                        needRefresh = MoveLayerInLayerOverlay(layer, layerOverlay, movementAction);
                    }
                }
                else if (overlay != null)
                {
                    needRefresh = MoveOverlay(overlay, movementAction);
                }
                else if (styleItem != null)
                {
                    var featureLayer = selectedItem.Parent.ConcreteObject as FeatureLayer;
                    if (featureLayer != null && selectedItem is StyleLayerListItem)
                    {
                        int from = 0, to = 0;
                        var array = ((StyleLayerListItem)selectedItem).ZoomLevelRange.Split(" to ".ToArray(), StringSplitOptions.RemoveEmptyEntries);
                        if (array.Length == 2)
                        {
                            int.TryParse(array[0].Replace("(", "").Trim(), out from);
                            int.TryParse(array[1].Replace(")", "").Trim(), out to);
                        }
                        needRefresh = MoveStyle(styleItem, featureLayer, from, to, movementAction);
                    }
                    else
                    {
                        var parent = selectedItem.Parent as StyleLayerListItem;
                        if (parent != null)
                        {
                            var currentIndex = parent.Children.IndexOf(selectedItem);
                            var styleCount   = parent.Children.Count;
                            switch (movementAction)
                            {
                            case MovementAction.Down:
                                if (currentIndex + 1 <= styleCount - 1)
                                {
                                    parent.Children.RemoveAt(currentIndex);
                                    parent.Children.Insert(currentIndex + 1, selectedItem);
                                    parent.UpdateConcreteObject();
                                    needRefresh = true;
                                }
                                break;

                            case MovementAction.Up:
                                if (currentIndex - 1 >= 0)
                                {
                                    parent.Children.RemoveAt(currentIndex);
                                    parent.Children.Insert(currentIndex - 1, selectedItem);
                                    parent.UpdateConcreteObject();
                                    needRefresh = true;
                                }
                                break;

                            case MovementAction.ToTop:
                                if (currentIndex != 0)
                                {
                                    parent.Children.RemoveAt(currentIndex);
                                    parent.Children.Insert(0, selectedItem);
                                    parent.UpdateConcreteObject();
                                    needRefresh = true;
                                }
                                break;

                            case MovementAction.ToBottom:
                                if (currentIndex != styleCount - 1)
                                {
                                    parent.Children.RemoveAt(currentIndex);
                                    parent.Children.Add(selectedItem);
                                    parent.UpdateConcreteObject();
                                    needRefresh = true;
                                }
                                break;
                            }
                        }
                    }
                    if (needRefresh)
                    {
                        var tileOverlay = LayerListHelper.FindMapElementInLayerList <TileOverlay>(GisEditor.LayerListManager.SelectedLayerListItem);
                        if (tileOverlay != null && tileOverlay.MapArguments != null)
                        {
                            tileOverlay.Invalidate();
                        }
                    }
                }
                if (needRefresh)
                {
                    GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(selectedItem, RefreshArgsDescription.MoveItemDescription));
                }
            }
        }
        private void InitializeOverlays()
        {
            string cacheFolder = Path.Combine(Path.GetTempPath(), "TileCache");

            WorldMapKitWmsWpfOverlay worldMapKitRoadOverlay = new WorldMapKitWmsWpfOverlay();

            worldMapKitRoadOverlay.Name       = Resources.WorldMapKitOverlayRoadName;
            worldMapKitRoadOverlay.TileHeight = 512;
            worldMapKitRoadOverlay.TileWidth  = 512;
            worldMapKitRoadOverlay.Projection = WorldMapKitProjection.SphericalMercator;
            worldMapKitRoadOverlay.MapType    = WorldMapKitMapType.Road;
            worldMapKitRoadOverlay.IsVisible  = true;
            worldMapKitRoadOverlay.TileCache  = new FileBitmapTileCache(cacheFolder, Resources.WorldMapKitOverlayRoadName);
            mapControl.Overlays.Add(worldMapKitRoadOverlay);

            WorldMapKitWmsWpfOverlay worldMapKitAerialOverlay = new WorldMapKitWmsWpfOverlay();

            worldMapKitAerialOverlay.Name       = Resources.WorldMapKitOverlayAerialName;
            worldMapKitAerialOverlay.TileHeight = 512;
            worldMapKitAerialOverlay.TileWidth  = 512;
            worldMapKitAerialOverlay.Projection = WorldMapKitProjection.SphericalMercator;
            worldMapKitAerialOverlay.MapType    = WorldMapKitMapType.Aerial;
            worldMapKitAerialOverlay.IsVisible  = false;
            worldMapKitAerialOverlay.TileCache  = new FileBitmapTileCache(cacheFolder, Resources.WorldMapKitOverlayAerialName);
            mapControl.Overlays.Add(worldMapKitAerialOverlay);

            WorldMapKitWmsWpfOverlay worldMapKitAerialWithLabelsOverlay = new WorldMapKitWmsWpfOverlay();

            worldMapKitAerialWithLabelsOverlay.Name       = Resources.WorldMapKitOverlayAerialWithLabelsName;
            worldMapKitAerialWithLabelsOverlay.TileHeight = 512;
            worldMapKitAerialWithLabelsOverlay.TileWidth  = 512;
            worldMapKitAerialWithLabelsOverlay.Projection = WorldMapKitProjection.SphericalMercator;
            worldMapKitAerialWithLabelsOverlay.MapType    = WorldMapKitMapType.AerialWithLabels;
            worldMapKitAerialWithLabelsOverlay.IsVisible  = false;
            worldMapKitAerialWithLabelsOverlay.TileCache  = new FileBitmapTileCache(cacheFolder, Resources.WorldMapKitOverlayAerialWithLabelsName);
            mapControl.Overlays.Add(worldMapKitAerialWithLabelsOverlay);

            OpenStreetMapOverlay openStreetMapOverlay = new OpenStreetMapOverlay();

            openStreetMapOverlay.Name       = Resources.OSMOverlayName;
            openStreetMapOverlay.TileHeight = 512;
            openStreetMapOverlay.TileWidth  = 512;
            openStreetMapOverlay.IsVisible  = false;
            openStreetMapOverlay.TileCache  = new FileBitmapTileCache(cacheFolder, Resources.OSMOverlayName);
            mapControl.Overlays.Add(openStreetMapOverlay);

            BingMapsOverlay bingMapsAerialOverlay = new BingMapsOverlay();

            bingMapsAerialOverlay.Name       = Resources.BingMapsAerialOverlayName;
            bingMapsAerialOverlay.TileHeight = 512;
            bingMapsAerialOverlay.TileWidth  = 512;
            bingMapsAerialOverlay.MapType    = Wpf.BingMapsMapType.Aerial;
            bingMapsAerialOverlay.IsVisible  = false;
            bingMapsAerialOverlay.TileCache  = new FileBitmapTileCache(cacheFolder, Resources.BingMapsAerialOverlayName);
            mapControl.Overlays.Add(bingMapsAerialOverlay);

            BingMapsOverlay bingMapsRoadOverlay = new BingMapsOverlay();

            bingMapsRoadOverlay.Name       = Resources.BingMapsRoadOverlayName;
            bingMapsRoadOverlay.TileHeight = 512;
            bingMapsRoadOverlay.TileWidth  = 512;
            bingMapsRoadOverlay.MapType    = Wpf.BingMapsMapType.Road;
            bingMapsRoadOverlay.IsVisible  = false;
            bingMapsRoadOverlay.TileCache  = new FileBitmapTileCache(cacheFolder, Resources.BingMapsRoadOverlayName);
            mapControl.Overlays.Add(bingMapsRoadOverlay);

            LayerOverlay styleLayersOverLay = new LayerOverlay();

            styleLayersOverLay.TileType = TileType.SingleTile;
            mapControl.Overlays.Add(Resources.StyleLayerOverLayKey, styleLayersOverLay);

            Proj4Projection wgs84ToMercatorProjection = new Proj4Projection();

            wgs84ToMercatorProjection.InternalProjectionParametersString = Proj4Projection.GetDecimalDegreesParametersString();
            wgs84ToMercatorProjection.ExternalProjectionParametersString = Proj4Projection.GetSphericalMercatorParametersString();

            EarthquakeHeatFeatureLayer heatLayer = new EarthquakeHeatFeatureLayer(new ShapeFileFeatureSource(ConfigurationManager.AppSettings["DataShapefileFileName"]));

            heatLayer.HeatStyle = new HeatStyle(10, 100, Resources.MagnitudeColumnName, 0, 12, 100, DistanceUnit.Kilometer);
            heatLayer.FeatureSource.Projection = wgs84ToMercatorProjection;
            heatLayer.Name = Resources.HeatStyleLayerName;
            styleLayersOverLay.Layers.Add(heatLayer);

            ShapeFileFeatureLayer pointLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["DataShapefileFileName"]);

            pointLayer.FeatureSource.Projection = wgs84ToMercatorProjection;
            pointLayer.Name = Resources.PointStyleLayerName;
            pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = PointStyles.CreateSimpleCircleStyle(GeoColor.StandardColors.Red, 6, GeoColor.StandardColors.White, 1);
            pointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            styleLayersOverLay.Layers.Add(pointLayer);

            EarthquakeIsoLineFeatureLayer isoLineLayer = new EarthquakeIsoLineFeatureLayer(new ShapeFileFeatureSource(ConfigurationManager.AppSettings["DataShapefileFileName"]));

            isoLineLayer.FeatureSource.Projection = wgs84ToMercatorProjection;
            isoLineLayer.Name = Resources.IsolineStyleLayerName;
            styleLayersOverLay.Layers.Add(isoLineLayer);

            //Setup TarckOverlay.
            mapControl.TrackOverlay             = new RadiusMearsureTrackInteractiveOverlay(DistanceUnit.Mile, mapControl.MapUnit);
            mapControl.TrackOverlay.TrackEnded += TrackOverlay_TrackEnded;

            LayerOverlay markerOverlay = new LayerOverlay();

            mapControl.Overlays.Add(Resources.MarkerOverlayKey, markerOverlay);

            PointStyle highLightStyle = new PointStyle();

            highLightStyle.CustomPointStyles.Add(PointStyles.CreateSimpleCircleStyle(GeoColor.FromArgb(50, GeoColor.SimpleColors.Blue), 20, GeoColor.SimpleColors.LightBlue, 1));
            highLightStyle.CustomPointStyles.Add(PointStyles.CreateSimpleCircleStyle(GeoColor.SimpleColors.LightBlue, 9, GeoColor.SimpleColors.Blue, 1));

            markerMemoryLayer = new InMemoryFeatureLayer();
            markerMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = PointStyles.CreateSimpleCircleStyle(GeoColor.SimpleColors.Orange, 8, GeoColor.SimpleColors.White, 1);
            markerMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            markerOverlay.Layers.Add(markerMemoryLayer);

            markerMemoryHighlightLayer = new InMemoryFeatureLayer();
            markerMemoryHighlightLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = highLightStyle;
            markerMemoryHighlightLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            markerOverlay.Layers.Add(markerMemoryHighlightLayer);

            ScaleBarAdornmentLayer scaleBarAdornmentLayer = new ScaleBarAdornmentLayer();

            scaleBarAdornmentLayer.UnitFamily = UnitSystem.Imperial;
            mapControl.AdornmentOverlay.Layers.Add(scaleBarAdornmentLayer);
        }
Exemplo n.º 48
0
        private void TestForm_Load(object sender, EventArgs e)
        {
            winformsMap1.MapUnit = GeographyUnit.Meter;
            winformsMap1.BackgroundOverlay.BackgroundBrush = new GeoSolidBrush(GeoColor.FromArgb(255, 198, 255, 255));

            GoogleMapsOverlay googleOverlay = new GoogleMapsOverlay(); //(@"Insert your key here!", @"C:\GoogleCache");

            googleOverlay.MapType = GoogleMapsMapType.Terrain;
            winformsMap1.Overlays.Add(googleOverlay);

            // This sets the zoom levels to map to Googles.  We next make sure we snap to the zoomlevels
            winformsMap1.ZoomLevelSet = new GoogleMapsZoomLevelSet();

            InMemoryFeatureLayer pointLayer = new InMemoryFeatureLayer();

            pointLayer.Open();
            pointLayer.Columns.Add(new FeatureSourceColumn("Text"));
            pointLayer.Close();

            //Sets the projection parameters to go from Geodetic (EPSG 4326) or decimal degrees to Google Map projection (Spherical Mercator).
            Proj4Projection proj4 = new Proj4Projection();

            proj4.InternalProjectionParametersString = Proj4Projection.GetEpsgParametersString(4326);
            proj4.ExternalProjectionParametersString = Proj4Projection.GetGoogleMapParametersString();
            //Applies the projection to the InMemoryFeatureLayer so that the point in decimal degrees (Longitude/Latitude) can be
            //match the projection of Google Map.
            pointLayer.FeatureSource.Projection = proj4;

            //Values in Longitude and Latitude.
            double Longitude = -95.2809;
            double Latitude  = 38.9543;


            //Creates the feature made of a PointShape with the Longitude and Latitude values.
            Feature GPSFeature = new Feature(new PointShape(Longitude, Latitude));

            //Format the Longitude and Latitude into a nice string as Degrees Minutes and Seconds
            string LongLat = DecimalDegreesHelper.GetDegreesMinutesSecondsStringFromDecimalDegreePoint(GPSFeature);

            //Sets the InMemoryFeatureLayer to have it displayed with Square symbol and with text.
            GPSFeature.ColumnValues.Add("Text", LongLat);
            pointLayer.InternalFeatures.Add(GPSFeature);

            pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimplePointStyle(PointSymbolType.Square,
                                                                                                       GeoColor.StandardColors.Red, GeoColor.StandardColors.Black, 2, 12);
            pointLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("Text", "Arial", 12, DrawingFontStyles.Bold,
                                                                                                    GeoColor.StandardColors.Black, GeoColor.StandardColors.White, 3, -10, 10);
            pointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            LayerOverlay pointOverlay = new LayerOverlay();

            pointOverlay.Layers.Add("PointLayer", pointLayer);
            winformsMap1.Overlays.Add("PointOverlay", pointOverlay);

            //Sets the extend of the map based on the GPS point.
            proj4.Open();
            Vertex projVertex = proj4.ConvertToExternalProjection(Longitude, Latitude);

            proj4.Close();

            double extendWidth  = 2300;
            double extendHeight = 1200;

            winformsMap1.CurrentExtent = new RectangleShape((projVertex.X - extendWidth), (projVertex.Y + extendHeight),
                                                            (projVertex.X + extendWidth), (projVertex.Y - extendHeight));

            winformsMap1.Refresh();
        }
Exemplo n.º 49
0
        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);
            SetContentView(Resource.Layout.DisplayASimpleMap);

            ShapeFileFeatureLayer txwatFeatureLayer = new ShapeFileFeatureLayer(SampleHelper.GetDataPath(@"Frisco/TXwat.shp"));

            txwatFeatureLayer.ZoomLevelSet.ZoomLevel12.DefaultAreaStyle.FillSolidBrush.Color = GeoColor.FromArgb(255, 153, 179, 204);
            txwatFeatureLayer.ZoomLevelSet.ZoomLevel12.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("LandName", "Arial", 9, DrawingFontStyles.Italic, GeoColor.StandardColors.Navy);
            txwatFeatureLayer.ZoomLevelSet.ZoomLevel12.DefaultTextStyle.SuppressPartialLabels = true;
            txwatFeatureLayer.ZoomLevelSet.ZoomLevel12.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            ShapeFileFeatureLayer txlkaA40FeatureLayer = new ShapeFileFeatureLayer(SampleHelper.GetDataPath(@"Frisco/TXlkaA40.shp"));

            txlkaA40FeatureLayer.ZoomLevelSet.ZoomLevel14.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.DarkGray, 1F, false);
            txlkaA40FeatureLayer.ZoomLevelSet.ZoomLevel15.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.White, 3F, GeoColor.StandardColors.DarkGray, 5F, true);
            txlkaA40FeatureLayer.ZoomLevelSet.ZoomLevel16.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.White, 8F, GeoColor.StandardColors.DarkGray, 10F, true);
            txlkaA40FeatureLayer.ZoomLevelSet.ZoomLevel16.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("[fedirp] [fename] [fetype] [fedirs]", "Arial", 10f, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, 0, -1);
            txlkaA40FeatureLayer.ZoomLevelSet.ZoomLevel16.DefaultTextStyle.SuppressPartialLabels = true;
            txlkaA40FeatureLayer.ZoomLevelSet.ZoomLevel16.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            txlkaA40FeatureLayer.DrawingMarginPercentage = 80;

            ShapeFileFeatureLayer txlkaA20FeatureLayer = new ShapeFileFeatureLayer(SampleHelper.GetDataPath(@"Frisco/TXlkaA20.shp"));

            txlkaA20FeatureLayer.ZoomLevelSet.ZoomLevel15.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.FromArgb(255, 255, 255, 128), 6, GeoColor.StandardColors.LightGray, 9, true);
            txlkaA20FeatureLayer.ZoomLevelSet.ZoomLevel16.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.FromArgb(255, 255, 255, 128), 9, GeoColor.StandardColors.LightGray, 12, true);
            txlkaA20FeatureLayer.ZoomLevelSet.ZoomLevel16.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("[fedirp] [fename] [fetype] [fedirs]", "Arial", 12, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, 0, -1);
            txlkaA20FeatureLayer.ZoomLevelSet.ZoomLevel16.DefaultTextStyle.SuppressPartialLabels = true;
            txlkaA20FeatureLayer.ZoomLevelSet.ZoomLevel16.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            Marker thinkGeoMarker = new Marker(BaseContext);

            thinkGeoMarker.Position = new PointShape(-96.809523, 33.128675);
            thinkGeoMarker.SetImageBitmap(Android.Graphics.BitmapFactory.DecodeResource(ThinkGeo.MapSuite.Android.Resources, Resource.Drawable.Pin));
            thinkGeoMarker.YOffset = -(int)(22 * ThinkGeo.MapSuite.Android.Resources.DisplayMetrics.Density);

            MarkerOverlay markerOverlay = new MarkerOverlay();

            markerOverlay.Markers.Add(thinkGeoMarker);

            ImageView imageView = new ImageView(this);

            imageView.SetImageResource(Resource.Drawable.ThinkGeoLogo);

            TextView textView = new TextView(this);

            textView.Text = string.Format("Longitude : {0:N4}" + "\r\n" + "Latitude : {1:N4}", thinkGeoMarker.Position.X, thinkGeoMarker.Position.Y);
            textView.SetTextColor(Color.Black);
            textView.SetTextSize(ComplexUnitType.Px, 22);

            LinearLayout linearLayout = new LinearLayout(this);

            linearLayout.SetPadding(10, 10, 10, 10);
            linearLayout.Orientation = Orientation.Vertical;
            linearLayout.AddView(imageView);
            linearLayout.AddView(textView);

            Popup popup = new Popup(this);

            popup.Position = thinkGeoMarker.Position;
            popup.YOffset  = (int)(-44 * ThinkGeo.MapSuite.Android.Resources.DisplayMetrics.Density);
            popup.XOffset  = (int)(4 * ThinkGeo.MapSuite.Android.Resources.DisplayMetrics.Density);
            popup.AddView(linearLayout);

            PopupOverlay popupOverlay = new PopupOverlay();

            popupOverlay.Popups.Add(popup);

            LayerOverlay layerOverlay = new LayerOverlay();

            layerOverlay.Layers.Add(txwatFeatureLayer);
            layerOverlay.Layers.Add(txlkaA20FeatureLayer);
            layerOverlay.Layers.Add(txlkaA40FeatureLayer);

            androidMap               = FindViewById <MapView>(Resource.Id.androidmap);
            androidMap.MapUnit       = GeographyUnit.DecimalDegree;
            androidMap.CurrentExtent = new RectangleShape(-96.8172, 33.1299, -96.8050, 33.1226);
            androidMap.Overlays.Add(layerOverlay);
            androidMap.Overlays.Add(markerOverlay);
            androidMap.Overlays.Add(popupOverlay);

            SampleViewHelper.InitializeInstruction(this, FindViewById <RelativeLayout>(Resource.Id.MainLayout), GetType());
        }
        /// <summary>
        /// Gets an overlay used as base map.
        /// </summary>
        public static LayerOverlay GetOverlayAsBaseMap()
        {
            // Create the LayerOverlay for displaying the map.
            LayerOverlay labelingStyleOverlay = new LayerOverlay();

            // Create the parcels layer.
            ShapeFileFeatureLayer parcelLayer = new ShapeFileFeatureLayer(string.Format(@"{0}\{1}", GetBaseDirectory(), "Parcels.shp"));

            parcelLayer.ZoomLevelSet.ZoomLevel10.DefaultAreaStyle    = new AreaStyle(new GeoPen(GeoColor.FromHtml("#d6d5d4"), 2), new GeoSolidBrush(GeoColor.FromHtml("#faf7f3")), PenBrushDrawingOrder.PenFirst);
            parcelLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            labelingStyleOverlay.Layers.Add("parcel", parcelLayer);

            // Create the pois layer.
            ShapeFileFeatureLayer restaurantsLayer = new ShapeFileFeatureLayer(string.Format(@"{0}\{1}", GetBaseDirectory(), "Pois.shp"));

            restaurantsLayer.ZoomLevelSet.ZoomLevel10.DefaultPointStyle   = new PointStyle(PointSymbolType.Circle, new GeoSolidBrush(GeoColor.FromHtml("#99cc33")), new GeoPen(GeoColor.FromHtml("#666666"), 1), 3);
            restaurantsLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            // Set DrawingMarginPercentage to a proper value to avoid some labels are cut-off
            restaurantsLayer.DrawingMarginPercentage = 300;
            labelingStyleOverlay.Layers.Add("street", restaurantsLayer);

            // Create the streets layer.
            ShapeFileFeatureLayer streetLayer = new ShapeFileFeatureLayer(string.Format(@"{0}\{1}", GetBaseDirectory(), "Street.shp"));

            // Add a copy of road stype to make sure the end of line shape is round cap.
            ClassBreakStyle roadStyleCopy  = new ClassBreakStyle("Type");
            ClassBreak      localRoadBreak = new ClassBreak();

            localRoadBreak.Value            = 6.9;
            localRoadBreak.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.FromHtml("#d6d5d4"), 8f), new GeoPen(GeoColor.FromHtml("#ffffff"), 6f));
            localRoadBreak.DefaultLineStyle.CenterPen.EndCap = DrawingLineCap.Round;
            localRoadBreak.DefaultLineStyle.OuterPen.EndCap  = DrawingLineCap.Round;
            roadStyleCopy.ClassBreaks.Add(localRoadBreak);
            streetLayer.ZoomLevelSet.ZoomLevel10.CustomStyles.Add(roadStyleCopy);

            // Define the style of streets based on its type.
            ClassBreakStyle roadStyle = new ClassBreakStyle("Type");

            roadStyle.BreakValueInclusion = BreakValueInclusion.ExcludeValue;

            ClassBreak highwayBreak = new ClassBreak();

            highwayBreak.Value            = 0.9;
            highwayBreak.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.FromHtml("#a2a09c"), 12f), new GeoPen(GeoColor.FromHtml("#f7c67f"), 10f));
            highwayBreak.DefaultLineStyle.CenterPen.EndCap = DrawingLineCap.Round;
            highwayBreak.DefaultLineStyle.OuterPen.EndCap  = DrawingLineCap.Round;
            roadStyle.ClassBreaks.Add(highwayBreak);

            ClassBreak majorRoadBreak = new ClassBreak();

            majorRoadBreak.Value            = 3.8;
            majorRoadBreak.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.FromHtml("#d6d5d4"), 10f), new GeoPen(GeoColor.FromHtml("#f5e8cb"), 8f));
            majorRoadBreak.DefaultLineStyle.CenterPen.EndCap = DrawingLineCap.Round;
            majorRoadBreak.DefaultLineStyle.OuterPen.EndCap  = DrawingLineCap.Round;
            roadStyle.ClassBreaks.Add(majorRoadBreak);

            ClassBreak minorRoadBreak = new ClassBreak();

            minorRoadBreak.Value            = 6.9;
            minorRoadBreak.DefaultLineStyle = new LineStyle(new GeoPen(GeoColor.SimpleColors.Transparent), new GeoPen(GeoColor.SimpleColors.Transparent));
            roadStyle.ClassBreaks.Add(minorRoadBreak);
            streetLayer.ZoomLevelSet.ZoomLevel10.CustomStyles.Add(roadStyle);

            streetLayer.ZoomLevelSet.ZoomLevel10.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            streetLayer.DrawingMarginPercentage = 200;
            labelingStyleOverlay.Layers.Add("poi", streetLayer);

            return(labelingStyleOverlay);
        }
Exemplo n.º 51
0
        /// <summary>
        /// Set up the map with the ThinkGeo Cloud Maps overlay and a feature layer containing Frisco zoning data
        /// </summary>
        protected override void OnAppearing()
        {
            base.OnAppearing();
            // Create the background world maps using vector tiles requested from the ThinkGeo Cloud Service.
            ThinkGeoCloudVectorMapsOverlay thinkGeoCloudVectorMapsOverlay = new ThinkGeoCloudVectorMapsOverlay("9ap16imkD_V7fsvDW9I8r8ULxgAB50BX_BnafMEBcKg~", "vtVao9zAcOj00UlGcK7U-efLANfeJKzlPuDB9nw7Bp4K4UxU_PdRDg~~", ThinkGeoCloudVectorMapsMapType.Light);

            thinkGeoCloudVectorMapsOverlay.VectorTileCache = new FileVectorTileCache(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "cache"), "CloudMapsVector");

            mapView.Overlays.Add(thinkGeoCloudVectorMapsOverlay);

            // Set the Map Unit to meters (used in Spherical Mercator)
            mapView.MapUnit = GeographyUnit.Meter;

            // Create a feature layer to hold and display the zoning data
            InMemoryFeatureLayer zoningLayer = new InMemoryFeatureLayer();

            // Add a style to use to draw the Frisco zoning polygons
            zoningLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            zoningLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle    = AreaStyle.CreateSimpleAreaStyle(GeoColor.FromArgb(50, GeoColors.MediumPurple), GeoColors.MediumPurple, 2);

            // Import the features from the Frisco zoning data shapefile
            ShapeFileFeatureSource zoningDataFeatureSource = new ShapeFileFeatureSource(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Data/Shapefile/Zoning.shp"));

            // Create a ProjectionConverter to convert the shapefile data from North Central Texas (2276) to Spherical Mercator (3857)
            ProjectionConverter projectionConverter = new ProjectionConverter(3857, 2276);

            // For this sample, we have to reproject the features before adding them to the feature layer
            // This is because the topological equality query often does not work when used on a feature layer with a ProjectionConverter, due to rounding issues between projections
            zoningDataFeatureSource.Open();
            projectionConverter.Open();
            foreach (Feature zoningFeature in zoningDataFeatureSource.GetAllFeatures(ReturningColumnsType.AllColumns))
            {
                Feature reprojectedFeature = projectionConverter.ConvertToInternalProjection(zoningFeature);
                zoningLayer.InternalFeatures.Add(reprojectedFeature);
            }
            zoningDataFeatureSource.Close();
            projectionConverter.Close();

            // Set the map extent to Frisco, TX
            //mapView.CurrentExtent = new RectangleShape(-10781137.28, 3917162.59, -10774579.34, 3911241.35);

            // Create a layer to hold the feature we will perform the spatial query against
            InMemoryFeatureLayer queryFeatureLayer = new InMemoryFeatureLayer();

            queryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle    = AreaStyle.CreateSimpleAreaStyle(GeoColor.FromArgb(75, GeoColors.LightRed), GeoColors.LightRed);
            queryFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            // Create a layer to hold features found by the spatial query
            InMemoryFeatureLayer highlightedFeaturesLayer = new InMemoryFeatureLayer();

            highlightedFeaturesLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle    = AreaStyle.CreateSimpleAreaStyle(GeoColor.FromArgb(90, GeoColors.MidnightBlue), GeoColors.MidnightBlue);
            highlightedFeaturesLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            // Add each feature layer to it's own overlay
            // We do this so we can control and refresh/redraw each layer individually
            LayerOverlay layerOverlay = new LayerOverlay();

            layerOverlay.Layers.Add("Frisco Zoning", zoningLayer);
            layerOverlay.Layers.Add("Query Feature", queryFeatureLayer);
            layerOverlay.Layers.Add("Highlighted Features", highlightedFeaturesLayer);

            mapView.Overlays.Add("Layer Overlay", layerOverlay);

            // Create a sample shape using vertices from an existing feature, to ensure that it is touching other features
            zoningLayer.Open();
            MultipolygonShape firstFeatureShape = (MultipolygonShape)zoningLayer.FeatureSource.GetAllFeatures(ReturningColumnsType.NoColumns).First().GetShape();

            // Get vertices from an existing feature
            var vertices = firstFeatureShape.Polygons.First().OuterRing.Vertices;

            // Create a new feature using a subset of those vertices
            MultipolygonShape sampleShape = new MultipolygonShape(new Collection <PolygonShape> {
                new PolygonShape(new RingShape(new Collection <Vertex> {
                    vertices[0], vertices[1], vertices[2]
                }))
            });

            queryFeatureLayer.InternalFeatures.Add(new Feature(sampleShape));
            zoningLayer.Close();
            GetFeaturesTouching(sampleShape);

            // Set the map extent to the sample shape
            mapView.CurrentExtent = new RectangleShape(-10778499.3056056, 3920951.91647677, -10774534.1347853, 3917536.13679426);

            mapView.Refresh();
        }
Exemplo n.º 52
0
        /// <summary>
        /// Setup the map with the ThinkGeo Cloud Maps overlay. Also, add the PostgreSql layer to the map
        /// </summary>
        protected override void OnAppearing()
        {
            base.OnAppearing();
            // It is important to set the map unit first to either feet, meters or decimal degrees.
            mapView.MapUnit = GeographyUnit.Meter;

            // Create the background world maps using vector tiles requested from the ThinkGeo Cloud Service and add it to the map.
            var thinkGeoCloudVectorMapsOverlay = new ThinkGeoCloudVectorMapsOverlay("9ap16imkD_V7fsvDW9I8r8ULxgAB50BX_BnafMEBcKg~", "vtVao9zAcOj00UlGcK7U-efLANfeJKzlPuDB9nw7Bp4K4UxU_PdRDg~~", ThinkGeoCloudVectorMapsMapType.Light);

            thinkGeoCloudVectorMapsOverlay.VectorTileCache = new FileVectorTileCache(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "cache"), "CloudMapsVector");
            mapView.Overlays.Add(thinkGeoCloudVectorMapsOverlay);

            // Create a new overlay that will hold our new layer and add it to the map.
            LayerOverlay coyoteSightingsOverlay = new LayerOverlay();

            mapView.Overlays.Add(coyoteSightingsOverlay);

            // Create the new layer and set the projection as the data is in srid 2276 as our background is srid 3857 (spherical mercator).
            PostgreSqlFeatureLayer coyoteSightingsLayer = new PostgreSqlFeatureLayer("User ID=thinkgeo_user;Password=cs%^%#trsdFG;Host=sampledatabases.thinkgeo.com;Port=5432;Database=thinkgeo_samples;Pooling=true;", "frisco_coyote_sightings", "id", 2276);

            coyoteSightingsLayer.FeatureSource.ProjectionConverter = new ProjectionConverter(2276, 3857);

            // Add the layer to the overlay we created earlier.
            coyoteSightingsOverlay.Layers.Add("Coyote Sightings", coyoteSightingsLayer);

            // Set a point style to zoom level 1 and then apply it to all zoom levels up to 20.
            coyoteSightingsLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = new PointStyle(PointSymbolType.Circle, 12, GeoBrushes.Red, new GeoPen(GeoColors.White, 2));
            coyoteSightingsLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            // Set the map view current extent to a bounding box that shows just a few sightings.
            mapView.CurrentExtent = new RectangleShape(-10784283.099060204, 3918532.598821122, -10781699.527518518, 3916820.409397046);

            // Refresh the map.
            mapView.Refresh();

            #region Create Sample Data Code

            // ========================================================
            // Code for creating the sample data in PostgreSql
            // ========================================================

            //    Collection<FeatureSourceColumn> columns = new Collection<FeatureSourceColumn>();
            //    columns.Add(new FeatureSourceColumn("comment", "varchar", 255));

            //    PostgreSqlFeatureSource target = new PostgreSqlFeatureSource("User ID={username};Password={password};Host=10.10.10.179;Port=5432;Database=thinkgeo_samples;Pooling=true;", "frisco_coyote_sightings", "ID", 2276);
            //    target.Open();

            //    ShapeFileFeatureSource source = new ShapeFileFeatureSource(@"../../../data/Frisco_Coyote_Sightings.shp");
            //    source.Open();

            //    var sourceFeatures = source.GetAllFeatures(ReturningColumnsType.AllColumns);

            //    target.BeginTransaction();

            //    foreach (var feature in sourceFeatures)
            //    {
            //        var dict = new Dictionary<string, string>();
            //        dict.Add("comment", feature.ColumnValues["Comments"].ToString().Replace('"', ' ').Replace("'", ""));
            //        dict.Add("id", feature.ColumnValues["OBJECTID"]);
            //        var newFeature = new Feature(feature.GetWellKnownBinary(), feature.ColumnValues["OBJECTID"], dict);

            //        target.AddFeature(newFeature);
            //    }

            //    var results = target.CommitTransaction();
            //    target.Close();

            //    target.Open();
            //    var features = target.GetAllFeatures(ReturningColumnsType.AllColumns);
            //    target.Close();
            #endregion
        }
        private void RefreshTimer_Tick(object sender, EventArgs e)
        {
            LayerOverlay layerOverlay = (LayerOverlay)Map1.Overlays["LayerOverlay"];

            Map1.Refresh(layerOverlay);
        }
Exemplo n.º 54
0
        void PlotSearch()
        {
            if (locationInitialised)
            {
                //use our web converter /pages/utmconverter.aspx?lat=-1.303&lon=36.90909
                string[] realpoint = null;
                var      request   = WebRequest.Create("http://40.68.99.44/GeoManagerField/pages/utmconverter.aspx?lat=" + _currentLocation.Latitude + "&lon=" + _currentLocation.Longitude) as HttpWebRequest;
                // request.Method = "GET";
                request.Method        = "POST";
                request.ContentLength = 0;
                request.ContentType   = "application/x-www-form-urlencoded";
                HttpWebResponse response;
                string          fullresponse = null;
                try
                {
                    response = (HttpWebResponse)request.GetResponse();
                    Stream       receiveStream = response.GetResponseStream();
                    StreamReader readStream    = new StreamReader(receiveStream, Encoding.UTF8);
                    fullresponse = readStream.ReadToEnd();
                    if (!fullresponse.StartsWith("0")) // getting 0 from response
                    {
                        string points = fullresponse.Substring(0, fullresponse.IndexOf("<")).Trim();
                        realpoint = points.Split(',');

                        double lat = 0;
                        double lon = 0;
                        if (double.TryParse(realpoint[0].ToString(), out lat) && double.TryParse(realpoint[1].ToString(), out lon))
                        {
                            pointLayer.InternalFeatures.Clear();
                            Feature gmp = new Feature(new PointShape(lat - 94.280, lon + 278.182));
                            pointLayer.InternalFeatures.Add(gmp);
                            androidMap.Refresh();

                            //  PointShape position = new PointShape(lat, lon);
                            //  LayerOverlay highlightOverlay = (LayerOverlay)androidMap.Overlays["cadastral"];
                            //  FeatureLayer highlightLayer = (FeatureLayer)highlightOverlay.Layers["Cadastral"];

                            //  highlightLayer.Open();
                            //  Collection<Feature> selectedFeatures = highlightLayer.QueryTools.GetFeaturesContaining(position, new string[1] { "Plotno_1" });
                            // highlightLayer.Close();

                            // if (selectedFeatures.Count > 0)
                            // {
                            //     androidMap.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();
                            //     RectangleShape featureextent = selectedFeatures[0].GetShape().GetBoundingBox();
                            //     androidMap.TrackOverlay.TrackShapeLayer.InternalFeatures.Add(selectedFeatures[0].Id, selectedFeatures[0]);
                            //    androidMap.CurrentExtent = featureextent;
                            //    androidMap.Refresh();
                            //turn on gps after
                            //   locationInitialised = true;
                            //  }
                            // else
                            // {
                            //     var msgDialog = new AlertDialog.Builder(this);
                            //     msgDialog.SetTitle("GeoManager Alert");
                            //    msgDialog.SetMessage("GPS Position: " + lat + "," + lon + " not found in map sheet or position not in a plot . . . please verify.");
                            //     msgDialog.SetPositiveButton("Ok", (s, ev) =>
                            //    {

                            //   });
                            //    msgDialog.Show();

                            // }
                        }
                        else
                        {
                            Toast.MakeText(this, "Incorrect GPS data conversion - string passed as decimal.", ToastLength.Short).Show();
                        }
                    }
                    else
                    {
                        Toast.MakeText(this, "Incorrect GPS data conversion - response 0", ToastLength.Short).Show();
                    }
                }
                catch (Exception)
                {
                    Toast.MakeText(this, "No internet connectivity for GPS Data Conversion . . verify.", ToastLength.Short).Show();
                }
            }
            else
            {
                var      inputDialog = new AlertDialog.Builder(this);
                EditText userInput   = new EditText(this);

                string selectedInput = string.Empty;

                userInput.InputType = Android.Text.InputTypes.ClassText | Android.Text.InputTypes.TextVariationNormal;
                inputDialog.SetTitle("Input LR No?");
                inputDialog.SetView(userInput);
                inputDialog.SetPositiveButton(
                    "Spatial Search",
                    (see, ess) =>
                {
                    if (userInput.Text != string.Empty && userInput.Text != "")
                    {
                        LayerOverlay highlightOverlay = (LayerOverlay)androidMap.Overlays["cadastral"];
                        FeatureLayer highlightLayer   = (FeatureLayer)highlightOverlay.Layers["Cadastral"];

                        highlightLayer.Open();
                        Collection <Feature> selectedFeatures = highlightLayer.QueryTools.GetFeaturesByColumnValue("Plotno_1", userInput.Text.Trim());
                        highlightLayer.Close();

                        if (selectedFeatures.Count > 0)
                        {
                            androidMap.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();
                            RectangleShape featureextent = selectedFeatures[0].GetShape().GetBoundingBox();
                            androidMap.TrackOverlay.TrackShapeLayer.InternalFeatures.Add(selectedFeatures[0].Id, selectedFeatures[0]);
                            androidMap.CurrentExtent = featureextent;
                            androidMap.Refresh();
                        }
                        else
                        {
                            var msgDialog = new AlertDialog.Builder(this);
                            msgDialog.SetTitle("GeoManager Alert");
                            msgDialog.SetMessage("LR No was not found in this map sheet . . . verify LR No");
                            msgDialog.SetPositiveButton("Ok", (s, ev) =>
                            {
                            });
                            msgDialog.Show();
                        }
                    }
                    HideKeyboard(userInput);
                });
                inputDialog.SetNegativeButton("CLOSE", (afk, kfa) => { HideKeyboard(userInput); });
                inputDialog.Show();
                ShowKeyboard(userInput);
            }
        }
        private void InitializeOverlays()
        {
            string cacheFolder = Path.Combine(Path.GetTempPath(), "TileCache");

            WorldMapKitWmsDesktopOverlay worldMapKitRoadOverlay = new WorldMapKitWmsDesktopOverlay();

            worldMapKitRoadOverlay.Name       = Resources.WorldMapKitRoadOverlay;
            worldMapKitRoadOverlay.Projection = WorldMapKitProjection.SphericalMercator;
            worldMapKitRoadOverlay.IsVisible  = true;
            worldMapKitRoadOverlay.TileCache  = new FileBitmapTileCache(cacheFolder, Resources.WorldMapKitRoadOverlay);
            worldMapKitRoadOverlay.MapType    = WorldMapKitMapType.Road;
            map.Overlays.Add(Resources.WorldMapKitRoadOverlay, worldMapKitRoadOverlay);

            WorldMapKitWmsDesktopOverlay worldMapKitAerialOverlay = new WorldMapKitWmsDesktopOverlay();

            worldMapKitAerialOverlay.Name       = Resources.WorldMapKitAerialOverlay;
            worldMapKitAerialOverlay.Projection = WorldMapKitProjection.SphericalMercator;
            worldMapKitAerialOverlay.IsVisible  = false;
            worldMapKitAerialOverlay.TileCache  = new FileBitmapTileCache(cacheFolder, Resources.WorldMapKitAerialOverlay);
            worldMapKitAerialOverlay.MapType    = WorldMapKitMapType.Aerial;
            map.Overlays.Add(Resources.WorldMapKitAerialOverlay, worldMapKitAerialOverlay);

            WorldMapKitWmsDesktopOverlay worldMapKitAerialWithLabelsOverlay = new WorldMapKitWmsDesktopOverlay();

            worldMapKitAerialWithLabelsOverlay.Name       = Resources.WorldMapKitAerialWithLabelsOverlay;
            worldMapKitAerialWithLabelsOverlay.Projection = WorldMapKitProjection.SphericalMercator;
            worldMapKitAerialWithLabelsOverlay.IsVisible  = false;
            worldMapKitAerialWithLabelsOverlay.TileCache  = new FileBitmapTileCache(cacheFolder, Resources.WorldMapKitAerialWithLabelsOverlay);
            worldMapKitAerialWithLabelsOverlay.MapType    = WorldMapKitMapType.AerialWithLabels;
            map.Overlays.Add(Resources.WorldMapKitAerialWithLabelsOverlay, worldMapKitAerialWithLabelsOverlay);

            OpenStreetMapOverlay openStreetMapOverlay = new OpenStreetMapOverlay();

            openStreetMapOverlay.Name      = Resources.OSMOverlayName;
            openStreetMapOverlay.IsVisible = false;
            openStreetMapOverlay.TileCache = new FileBitmapTileCache(cacheFolder, Resources.OpenStreetMapKey);
            map.Overlays.Add(Resources.OpenStreetMapKey, openStreetMapOverlay);

            BingMapsOverlay bingMapsAerialOverlay = new BingMapsOverlay();

            bingMapsAerialOverlay.Name      = Resources.BingMapsAerialOverlayName;
            bingMapsAerialOverlay.MapType   = WinForms.BingMapsMapType.Aerial;
            bingMapsAerialOverlay.IsVisible = false;
            bingMapsAerialOverlay.TileCache = new FileBitmapTileCache(cacheFolder, Resources.BingMapsAerial);
            map.Overlays.Add(Resources.BingMapsAerial, bingMapsAerialOverlay);

            BingMapsOverlay bingMapsRoadOverlay = new BingMapsOverlay();

            bingMapsRoadOverlay.Name      = Resources.BingMapsRoadOverlayName;
            bingMapsRoadOverlay.MapType   = WinForms.BingMapsMapType.Road;
            bingMapsRoadOverlay.IsVisible = false;
            bingMapsRoadOverlay.TileCache = new FileBitmapTileCache(cacheFolder, Resources.BingMapsRoad);
            map.Overlays.Add(Resources.BingMapsRoad, bingMapsRoadOverlay);

            LayerOverlay styleLayersOverLay = new LayerOverlay();

            map.Overlays.Add(Resources.StyleLayerOverLayKey, styleLayersOverLay);

            Proj4Projection wgs84ToMercatorProjection = new Proj4Projection();

            wgs84ToMercatorProjection.InternalProjectionParametersString = Proj4Projection.GetDecimalDegreesParametersString();
            wgs84ToMercatorProjection.ExternalProjectionParametersString = Proj4Projection.GetSphericalMercatorParametersString();

            EarthquakeHeatFeatureLayer heatLayer = new EarthquakeHeatFeatureLayer(new ShapeFileFeatureSource(ConfigurationManager.AppSettings["DataShapefileFileName"]));

            heatLayer.IsVisible = false;
            heatLayer.HeatStyle = new HeatStyle(10, 100, Resources.MagnitudeColumnName, 0, 12, 100, DistanceUnit.Kilometer);
            heatLayer.FeatureSource.Projection = wgs84ToMercatorProjection;
            heatLayer.Name = Resources.HeatStyleLayerName;
            styleLayersOverLay.Layers.Add(heatLayer);

            ShapeFileFeatureLayer pointLayer = new ShapeFileFeatureLayer(ConfigurationManager.AppSettings["DataShapefileFileName"]);

            pointLayer.IsVisible = false;
            pointLayer.FeatureSource.Projection = wgs84ToMercatorProjection;
            pointLayer.Name = Resources.PointStyleLayerName;
            pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = PointStyles.CreateSimpleCircleStyle(GeoColor.StandardColors.Red, 6, GeoColor.StandardColors.White, 1);
            pointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            styleLayersOverLay.Layers.Add(pointLayer);

            FeatureSource isoLineFeatureSource         = new ShapeFileFeatureSource(ConfigurationManager.AppSettings["DataShapefileFileName"]);
            EarthquakeIsoLineFeatureLayer isoLineLayer = new EarthquakeIsoLineFeatureLayer(isoLineFeatureSource);

            isoLineLayer.IsVisible = false;
            isoLineLayer.FeatureSource.Projection = wgs84ToMercatorProjection;
            isoLineLayer.Name = Resources.IsolineStyleLayerName;
            styleLayersOverLay.Layers.Add(isoLineLayer);

            LayerOverlay queryResultMarkerOverlay = new LayerOverlay();

            map.Overlays.Add("QueryResultMarkerOverlay", queryResultMarkerOverlay);

            PointStyle highlightStyle = new PointStyle();

            highlightStyle.CustomPointStyles.Add(PointStyles.CreateSimpleCircleStyle(GeoColor.FromArgb(50, GeoColor.SimpleColors.Blue), 20, GeoColor.SimpleColors.LightBlue, 1));
            highlightStyle.CustomPointStyles.Add(PointStyles.CreateSimpleCircleStyle(GeoColor.SimpleColors.LightBlue, 9, GeoColor.SimpleColors.Blue, 1));

            markerMemoryLayer = new InMemoryFeatureLayer();
            markerMemoryLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = PointStyles.CreateSimpleCircleStyle(GeoColor.SimpleColors.Orange, 8, GeoColor.SimpleColors.White, 1);
            markerMemoryLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            queryResultMarkerOverlay.Layers.Add(markerMemoryLayer);

            markerMemoryHighlightLayer = new InMemoryFeatureLayer();
            markerMemoryHighlightLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = highlightStyle;
            markerMemoryHighlightLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            queryResultMarkerOverlay.Layers.Add(markerMemoryHighlightLayer);
        }
Exemplo n.º 56
0
        protected override void InitializeMap()
        {
            MapView.MapUnit       = GeographyUnit.Meter;
            MapView.ZoomLevelSet  = new ThinkGeoCloudMapsZoomLevelSet();
            MapView.CurrentExtent = new RectangleShape(-13886070, 5660597, -8906057, 2382985);

            /*===========================================
            *  Backgrounds for this sample are powered by ThinkGeo Cloud Maps and require
            *  a Client ID and Secret. These were sent to you via email when you signed up
            *  with ThinkGeo, or you can register now at https://cloud.thinkgeo.com.
            *  ===========================================*/
            ThinkGeoCloudRasterMapsOverlay thinkGeoCloudMapsOverlay = (ThinkGeoCloudRasterMapsOverlay)MapView.Overlays["WMK"];
            string baseFolder        = Android.OS.Environment.ExternalStorageDirectory.AbsolutePath;
            string cachePathFilename = Path.Combine(baseFolder, "MapSuiteTileCaches/SampleCaches.db");

            thinkGeoCloudMapsOverlay.TileCache = new SqliteBitmapTileCache(cachePathFilename, "SphericalMercator");

            LineStyle lineStyle = LineStyles.CreateSimpleLineStyle(GeoColor.FromArgb(255, 50, 0, 249), 4, false);

            //Cold Front
            CustomGeoImageLineStyle coldFrontLineStyle = GetCustomLineStyle(lineStyle, 19, CustomGeoImageLineStyle.SymbolSide.Right,
                                                                            SampleHelper.GetDataPath(@"CustomStyles/offset_circle_red_bl.png"), SampleHelper.GetDataPath(@"CustomStyles/offset_triangle_blue_revert.png"));

            InMemoryFeatureLayer inMemoryFeatureLayerColdFront = new InMemoryFeatureLayer();

            inMemoryFeatureLayerColdFront.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(coldFrontLineStyle);
            inMemoryFeatureLayerColdFront.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            inMemoryFeatureLayerColdFront.InternalFeatures.Add(new Feature(File.ReadAllText(SampleHelper.GetDataPath(@"CustomStyles/ColdFront2.txt"))));
            inMemoryFeatureLayerColdFront.InternalFeatures.Add(new Feature(File.ReadAllText(SampleHelper.GetDataPath(@"CustomStyles/ColdFront3.txt"))));

            //Warm Front
            InMemoryFeatureLayer    inMemoryFeatureLayerWarmFront = new InMemoryFeatureLayer();
            CustomGeoImageLineStyle warmFrontLineStyle            = new CustomGeoImageLineStyle(lineStyle, new GeoImage(SampleHelper.GetDataPath(@"CustomStyles/offset_circle_blue.png")),
                                                                                                30, CustomGeoImageLineStyle.SymbolSide.Right);

            inMemoryFeatureLayerWarmFront.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(warmFrontLineStyle);
            inMemoryFeatureLayerWarmFront.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            inMemoryFeatureLayerWarmFront.InternalFeatures.Add(new Feature(File.ReadAllText(SampleHelper.GetDataPath(@"CustomStyles/WarmFront5.txt"))));
            inMemoryFeatureLayerWarmFront.InternalFeatures.Add(new Feature(File.ReadAllText(SampleHelper.GetDataPath(@"CustomStyles/WarmFront6.txt"))));
            inMemoryFeatureLayerWarmFront.InternalFeatures.Add(new Feature(File.ReadAllText(SampleHelper.GetDataPath(@"CustomStyles/WarmFront7.txt"))));
            inMemoryFeatureLayerWarmFront.InternalFeatures.Add(new Feature(File.ReadAllText(SampleHelper.GetDataPath(@"CustomStyles/WarmFront8.txt"))));

            //Occluded Front
            InMemoryFeatureLayer    inMemoryFeatureLayerOccludedFront = new InMemoryFeatureLayer();
            CustomGeoImageLineStyle occludedFrontLineStyle            = GetCustomLineStyle(lineStyle, 45, CustomGeoImageLineStyle.SymbolSide.Right,
                                                                                           SampleHelper.GetDataPath(@"CustomStyles/offset_triangle_and_circle_blue.png"), SampleHelper.GetDataPath(@"CustomStyles/offset_triangle_and_circle_red.png"));

            inMemoryFeatureLayerOccludedFront.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(occludedFrontLineStyle);
            inMemoryFeatureLayerOccludedFront.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            inMemoryFeatureLayerOccludedFront.InternalFeatures.Add(new Feature(File.ReadAllText(SampleHelper.GetDataPath(@"CustomStyles/OccludedFront9.txt"))));
            inMemoryFeatureLayerOccludedFront.InternalFeatures.Add(new Feature(File.ReadAllText(SampleHelper.GetDataPath(@"CustomStyles/OccludedFront10.txt"))));
            inMemoryFeatureLayerOccludedFront.InternalFeatures.Add(new Feature(File.ReadAllText(SampleHelper.GetDataPath(@"CustomStyles/OccludedFront11.txt"))));

            PressureValueStyle pressureValueStyle = new PressureValueStyle();

            pressureValueStyle.ColumnName = "Pressure";

            InMemoryFeatureLayer pressureFeatureLayer = new InMemoryFeatureLayer();

            pressureFeatureLayer.Open();
            pressureFeatureLayer.Columns.Add(new FeatureSourceColumn("Pressure"));
            pressureFeatureLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(pressureValueStyle);
            pressureFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            pressureFeatureLayer.InternalFeatures.Add(new Feature(MapView.CurrentExtent.GetCenterPoint()));

            Random random = new Random();

            string[] pressures = { "H", "L" };
            for (int i = 0; i < 20; i++)
            {
                Feature pressurePoint = new Feature(random.Next(-13886070, -8906057), random.Next(3382985, 6660597));
                pressurePoint.ColumnValues["Pressure"] = pressures[random.Next(0, 2)];
                pressureFeatureLayer.InternalFeatures.Add(pressurePoint);
            }

            WindPointStyle windStyle1 = new WindPointStyle("TEXT", "LEVEL", "ANGLE", GeoColor.FromHtml("#0AF8F8"));
            WindPointStyle windStyle2 = new WindPointStyle("TEXT", "LEVEL", "ANGLE", GeoColor.FromHtml("#0FF5B0"));
            WindPointStyle windStyle3 = new WindPointStyle("TEXT", "LEVEL", "ANGLE", GeoColor.FromHtml("#F7F70D"));
            WindPointStyle windStyle4 = new WindPointStyle("TEXT", "LEVEL", "ANGLE", GeoColor.FromHtml("#FBE306"));

            ClassBreakStyle windClassBreakStyle = new ClassBreakStyle();

            windClassBreakStyle.ColumnName = "TEXT";
            windClassBreakStyle.ClassBreaks.Add(new ClassBreak(10, new Collection <Style> {
                windStyle1
            }));
            windClassBreakStyle.ClassBreaks.Add(new ClassBreak(20, new Collection <Style> {
                windStyle2
            }));
            windClassBreakStyle.ClassBreaks.Add(new ClassBreak(30, new Collection <Style> {
                windStyle3
            }));
            windClassBreakStyle.ClassBreaks.Add(new ClassBreak(40, new Collection <Style> {
                windStyle4
            }));

            InMemoryFeatureLayer windFeatureLayer = new InMemoryFeatureLayer();

            windFeatureLayer.Open();
            windFeatureLayer.Columns.Add(new FeatureSourceColumn("TEXT"));
            windFeatureLayer.Columns.Add(new FeatureSourceColumn("ANGLE"));
            windFeatureLayer.Columns.Add(new FeatureSourceColumn("LEVEL"));
            windFeatureLayer.ZoomLevelSet.ZoomLevel01.CustomStyles.Add(windClassBreakStyle);
            windFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            for (int i = 0; i < 20; i++)
            {
                Feature windFeature = new Feature(random.Next(-13886070, -8906057), random.Next(3382985, 6660597));
                windFeature.ColumnValues["TEXT"]  = random.Next(10, 40).ToString(CultureInfo.InvariantCulture);
                windFeature.ColumnValues["ANGLE"] = random.Next(0, 360).ToString(CultureInfo.InvariantCulture);
                windFeature.ColumnValues["LEVEL"] = random.Next(0, 5).ToString(CultureInfo.InvariantCulture);
                windFeatureLayer.InternalFeatures.Add(windFeature);
            }

            LayerOverlay dynamicOverlay = new LayerOverlay();

            dynamicOverlay.Layers.Add(inMemoryFeatureLayerColdFront);
            dynamicOverlay.Layers.Add(inMemoryFeatureLayerWarmFront);
            dynamicOverlay.Layers.Add(inMemoryFeatureLayerOccludedFront);
            dynamicOverlay.Layers.Add(pressureFeatureLayer);
            dynamicOverlay.Layers.Add(windFeatureLayer);
            MapView.Overlays.Add(dynamicOverlay);
        }
        private static void AddFeatureToInMemoryFeatureLayer(InMemoryFeatureLayer inMemoryFeatureLayer, FeatureLayer sourceLayer)
        {
            if (inMemoryFeatureLayer == null)
            {
                string name         = "ExportResults";
                string existingName = string.Empty;
                InMemoryFeatureLayer existingLayer = GisEditor.ActiveMap.Overlays.OfType <LayerOverlay>()
                                                     .SelectMany(o => o.Layers).OfType <InMemoryFeatureLayer>()
                                                     .FirstOrDefault(l => l.Name.Equals(name, System.StringComparison.Ordinal));
                if (existingLayer != null)
                {
                    existingName = existingLayer.Name;
                }

                int index = 0;
                while (name.Equals(existingName))
                {
                    index++;
                    name          = "ExportResults" + index;
                    existingLayer = GisEditor.ActiveMap.Overlays.OfType <LayerOverlay>()
                                    .SelectMany(o => o.Layers).OfType <InMemoryFeatureLayer>()
                                    .FirstOrDefault(l => l.Name.Equals(name, System.StringComparison.Ordinal));
                    existingName = existingLayer != null ? existingLayer.Name : string.Empty;
                }

                GetLayersParameters parameters = new GetLayersParameters();
                parameters.LayerUris.Add(new Uri("mem:" + name));
                InMemoryFeatureLayerPlugin plugin = GisEditor.LayerManager.GetActiveLayerPlugins <InMemoryFeatureLayerPlugin>().FirstOrDefault();
                if (plugin != null)
                {
                    inMemoryFeatureLayer = plugin.GetLayers(parameters).OfType <InMemoryFeatureLayer>().FirstOrDefault();
                }
                GisEditor.ActiveMap.AddLayerToActiveOverlay(inMemoryFeatureLayer, TargetLayerOverlayType.Dynamic);
            }

            //if (sourceLayer != null)
            //{
            //    foreach (var item in sourceLayer.FeatureSource.LinkExpressions)
            //    {
            //        inMemoryFeatureLayer.FeatureSource.LinkExpressions.Add(item);
            //    }
            //    foreach (var item in sourceLayer.FeatureSource.LinkSources)
            //    {
            //        inMemoryFeatureLayer.FeatureSource.LinkSources.Add(item);
            //    }
            //}

            Collection <Feature> features = GisEditor.SelectionManager.GetSelectedFeatures();

            AddFeaturesToInMemoryFeatureLayer(inMemoryFeatureLayer, features);

            GisEditor.ActiveMap.Refresh(GisEditor.ActiveMap.ActiveOverlay);
            RefreshArgs refreshArgs = new RefreshArgs(GisEditor.ActiveMap, RefreshArgsDescription.AddLayerGroupCommandDescription);

            GisEditor.UIManager.BeginRefreshPlugins(refreshArgs);
            LayerOverlay overlay = GisEditor.ActiveMap.ActiveOverlay as LayerOverlay;

            if (overlay != null)
            {
                overlay.Invalidate();
            }
        }
        private void Form2_Load(object sender, EventArgs e)
        {
            //ShapeFile path name
            String path = @"..\..\Data\Countries02.shp";

            //World map colour
            GeoColor mapcol;

            mapcol = new GeoColor(255, 130, 200, 100);

            //Border colour
            GeoColor borderLineCol;

            borderLineCol = new GeoColor(255, 118, 138, 69);



            //Set the unit to be used for the map element. This must be set!
            winformsMap1.MapUnit = GeographyUnit.DecimalDegree;

            //Creates a new layer referencing a shapefile which is a parameter accepted in its constructor
            ShapeFileFeatureLayer worldLayer = new ShapeFileFeatureLayer(path);
            //A style instance to style the appearence of the shapefile
            AreaStyle areaStyle = new AreaStyle();

            //Area style accepts GeoSolidBrush in one of its constructors
            //GeoSolidBrush accepts GeoColor
            //GeoColor accepts a range of signatures one being 4 integer values
            //1:Alpha 2:red 3:green 4:blue
            areaStyle.FillSolidBrush = new GeoSolidBrush(mapcol);
            //Another accepted signature is GeoPen
            //GeoPen then accepts Geocolor and a Single data type value representing the width of the line
            areaStyle.OutlinePen           = new GeoPen(borderLineCol, 2);
            areaStyle.OutlinePen.DashStyle = LineDashStyle.Solid;

            //Set the worldLayer with a preset style
            worldLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = areaStyle;
            //The line below applies the style define above to all default zoom levels (1 through 20)
            worldLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            //We now have all the require elements to store the layer in a Layer Overlay object
            //Create a new Layer Overlay object to store the layer defined above
            LayerOverlay layer1;

            layer1 = new LayerOverlay();

            //Add the shapefile referenced above
            layer1.Layers.Add(worldLayer);

            //Add the layer overlay to the map
            //This is our first layer
            winformsMap1.Overlays.Add(layer1);

            //Set a proper extent for the map
            //From this a scale is generated
            winformsMap1.CurrentExtent = new RectangleShape(-134, 70, -56, 7);

            //The Refresh() method in the winformsMap object needs to be called to
            //redraw the map based on the data define above
            winformsMap1.Refresh();
        }
Exemplo n.º 59
0
        /// <summary>
        /// Set up the map with the ThinkGeo Cloud Maps overlay and a feature layer containing Frisco zoning data
        /// </summary>
        protected override void OnAppearing()
        {
            base.OnAppearing();
            // Create the background world maps using vector tiles requested from the ThinkGeo Cloud Service.
            ThinkGeoCloudVectorMapsOverlay thinkGeoCloudVectorMapsOverlay = new ThinkGeoCloudVectorMapsOverlay("9ap16imkD_V7fsvDW9I8r8ULxgAB50BX_BnafMEBcKg~", "vtVao9zAcOj00UlGcK7U-efLANfeJKzlPuDB9nw7Bp4K4UxU_PdRDg~~", ThinkGeoCloudVectorMapsMapType.Light);

            thinkGeoCloudVectorMapsOverlay.VectorTileCache = new FileVectorTileCache(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "cache"), "CloudMapsVector");

            mapView.Overlays.Add(thinkGeoCloudVectorMapsOverlay);

            // Set the Map Unit to meters (used in Spherical Mercator)
            mapView.MapUnit = GeographyUnit.Meter;

            // Create a feature layer to hold the Frisco zoning data
            ShapeFileFeatureLayer zoningLayer = new ShapeFileFeatureLayer(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Data/Shapefile/Zoning.shp"));

            // Convert the Frisco shapefile from its native projection to Spherical Mercator, to match the map
            ProjectionConverter projectionConverter = new ProjectionConverter(2276, 3857);

            zoningLayer.FeatureSource.ProjectionConverter = projectionConverter;

            // Add a style to use to draw the Frisco zoning polygons
            zoningLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
            zoningLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle    = AreaStyle.CreateSimpleAreaStyle(GeoColor.FromArgb(50, GeoColors.MediumPurple), GeoColors.MediumPurple, 2);

            // Set the map extent to Frisco, TX
            //mapView.CurrentExtent = new RectangleShape(-10781137.28, 3917162.59, -10774579.34, 3911241.35);

            // Create a layer to hold the feature we will perform the spatial query against
            InMemoryFeatureLayer queryFeatureLayer = new InMemoryFeatureLayer();

            queryFeatureLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle    = AreaStyle.CreateSimpleAreaStyle(GeoColor.FromArgb(75, GeoColors.LightRed), GeoColors.LightRed);
            queryFeatureLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            // Create a layer to hold features found by the spatial query
            InMemoryFeatureLayer highlightedFeaturesLayer = new InMemoryFeatureLayer();

            highlightedFeaturesLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle    = AreaStyle.CreateSimpleAreaStyle(GeoColor.FromArgb(90, GeoColors.MidnightBlue), GeoColors.MidnightBlue);
            highlightedFeaturesLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;

            // Add each feature layer to it's own overlay
            // We do this so we can control and refresh/redraw each layer individually
            LayerOverlay layerOverlay = new LayerOverlay();

            layerOverlay.Layers.Add("Frisco Zoning", zoningLayer);
            layerOverlay.Layers.Add("Query Feature", queryFeatureLayer);
            layerOverlay.Layers.Add("Highlighted Features", highlightedFeaturesLayer);


            mapView.Overlays.Add("Layer Overlay", layerOverlay);

            // Add an event to handle new shapes that are drawn on the map
            mapView.TrackOverlay.TrackEnded += OnPolygonDrawn;

            // Add a sample shape to the map for the initial query
            PolygonShape sampleShape = new PolygonShape("POLYGON((-10780418.9504333 3915973.97146252,-10780428.5050618 3913422.88551189,-10775737.1824769 3913413.33088341,-10775612.9723066 3915954.86220556,-10780418.9504333 3915973.97146252))");

            GetFeaturesDisjoint(sampleShape);

            // Set the map extent to the sample shapes
            mapView.CurrentExtent = RectangleShape.ScaleUp(sampleShape.GetBoundingBox(), 20).GetBoundingBox();


            mapView.Refresh();
        }
Exemplo n.º 60
0
        void AddLayers()
        {
            var colors = new List <Color>
            {
                Color.Red,
                Color.Blue,
                Color.Yellow,
                Color.Green,
                Color.Brown,
                Color.Orange,
                Color.Purple
            };

            string[]            fnames  = GetShapefiles();
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.SetTitle("Select Shape File?");
            builder.SetItems(fnames, (sender, args) =>
            {
                if (fnames[args.Which] != null)
                {
                    //  Toast.MakeText( this , "Choose existing Service picked" +  fnames [args.Which], ToastLength.Short).Show();
                    string layername             = fnames[args.Which];
                    ShapeFileFeatureLayer nLayer = new ShapeFileFeatureLayer(System.IO.Path.Combine(Android.OS.Environment.GetExternalStoragePublicDirectory(Android.OS.Environment.DirectoryDownloads).ToString(), layername), ShapeFileReadWriteMode.ReadOnly);
                    nLayer.RequireIndex          = false;
                    nLayer.Open();

                    if (nLayer.GetShapeFileType() == ShapeFileType.Point)
                    {
                        nLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle   = PointStyles.CreateSimplePointStyle(PointSymbolType.Circle, GeoColor.StandardColors.Red, GeoColor.StandardColors.Orange, 2);
                        nLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
                    }
                    else if (nLayer.GetShapeFileType() == ShapeFileType.Polyline)
                    {
                        nLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle    = LineStyles.CreateSimpleLineStyle(GeoColor.StandardColors.LightPink, 2, GeoColor.StandardColors.Black, 0, false);
                        nLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
                    }
                    else if (nLayer.GetShapeFileType() == ShapeFileType.Polygon)

                    {
                        nLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(
                            GeoColor.FromArgb(100, GeoColor.StandardColors.LightYellow), GeoColor.StandardColors.Blue);
                    }
                    var v           = nLayer.QueryTools.GetColumns();
                    string[] fields = new string[v.Count];
                    //for (int i = 0; i<v.Count ; ++i)
                    int i = 0;
                    foreach (FeatureSourceColumn c in v)
                    {
                        fields[i] = c.ColumnName;
                        i++;
                    }
                    AlertDialog.Builder bld = new AlertDialog.Builder(this);
                    bld.SetTitle("Select labelling field?");
                    bld.SetItems(fields, (senders, argss) =>
                    {
                        if (fields[argss.Which] != null)
                        {
                            string d = fields[argss.Which].ToString();
                            if (nLayer.GetShapeFileType() == ShapeFileType.Polyline)
                            {
                                nLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = TextStyles.LocalRoad1(fields[argss.Which]);
                            }
                            else
                            {
                                nLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = new TextStyle(fields[argss.Which], new GeoFont("Arail", 9, DrawingFontStyles.Bold), new GeoSolidBrush(GeoColor.SimpleColors.Black));
                            }
                            nLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;
                            nLayer.Close();
                            nLayer.FeatureSource.Projection = proj4;
                            LayerOverlay lOverlay           = new LayerOverlay();
                            lOverlay.Layers.Add(layername, nLayer);
                            androidMap.Overlays.Add(layername, lOverlay);
                            androidMap.Refresh();
                        }
                    });
                    bld.Create().Show();
                }
                else if (fnames[args.Which] == null)
                {
                    Toast.MakeText(this, "Cancel picked", ToastLength.Short).Show();
                    //How to close dialog Here
                }
            });
            builder.Create().Show();
        }