====== Source Code XamarinFormsEditionSample GeometricFunctions.zip ======

====App.cs====

<code csharp>   
 using System;  
 using Xamarin.Forms;  
  
 namespace GeometricFunc  
 {  
     public class App : Application  
     {  
         private MasterDetailPage mainPage;  
  
         public App()  
         {  
             InitializeStyles();  
             mainPage = new MasterDetailPage();  
  
             SampleListPage sampleListPage = new SampleListPage();  
             sampleListPage.SelectedSampleChanged += SampleListViewModel_SelectedSampleChanged;  
  
             sampleListPage.SelectedSample = sampleListPage.Samples[0];  
             mainPage.Master = sampleListPage;  
             MainPage = mainPage;  
         }  
  
         private void SampleListViewModel_SelectedSampleChanged(object sender, EventArgs e)  
         {  
             ContentPage mainContentPage = null;  
             SampleListPage sampleListViewModel = (SampleListPage)sender;  
             BaseSampleView newSample = (BaseSampleView)Activator.CreateInstance(sampleListViewModel.SelectedSample.ClassType);  
  
             if (mainPage.Detail == null)  
             {  
                 mainContentPage = new ContentPage();  
                 mainPage.Detail = new NavigationPage(mainContentPage);  
             }  
  
             NavigationPage navigationPage = (NavigationPage)mainPage.Detail;  
             mainContentPage = (ContentPage)navigationPage.CurrentPage;  
  
             BaseSampleView oldSample = mainContentPage.Content as BaseSampleView;  
             if (oldSample != null && !newSample.Equals(oldSample))  
             {  
                 oldSample.Dispose();  
             }  
  
             mainContentPage.Content = newSample;  
             mainContentPage.Title = newSample.Name;  
             mainContentPage.ToolbarItems.Clear();  
             mainContentPage.ToolbarItems.Add(newSample.SampleToolbarItem);  
             mainPage.IsPresented = false;  
         }  
  
         private void InitializeStyles()  
         {  
             Application.Current.Resources = new ResourceDictionary();  
  
             Style headerStyle = new Style(typeof(ContentView));  
             headerStyle.Setters.Add(new Setter { Property = ContentView.PaddingProperty, Value = new Thickness(5, Device.OnPlatform(38, 5, 0), 5, 0) });  
             Application.Current.Resources.Add("ListHeaderStyle", headerStyle);  
  
             Style settingsTitleStyle = new Style(typeof(Label));  
             settingsTitleStyle.Setters.Add(new Setter { Property = Label.TextColorProperty, Value = Color.Black });  
             settingsTitleStyle.Setters.Add(new Setter { Property = Label.FontSizeProperty, Value = 21 });  
             settingsTitleStyle.Setters.Add(new Setter { Property = Label.FontAttributesProperty, Value = FontAttributes.Bold });  
             Application.Current.Resources.Add("SettingsTitleStyle", settingsTitleStyle);  
         }  
     }  
 }  
  
 </code>

====AssemblyInfo.cs====

<code csharp>   
 using System.Resources;  
 using System.Reflection;  
  
 // General Information about an assembly is controlled through the following  
 // set of attributes. Change these attribute values to modify the information  
 // associated with an assembly.  
 [assembly:|AssemblyTitle("GeometricFunc")]  
 [assembly: AssemblyDescription("")]  
 [assembly:|AssemblyConfiguration("")]  
 [assembly: AssemblyCompany("")]  
 [assembly:|AssemblyProduct("GeometricFunc")]  
 [assembly: AssemblyCopyright("Copyright ©  2015")]  
 [assembly:|AssemblyTrademark("")]  
 [assembly: AssemblyCulture("")]  
 [assembly:|NeutralResourcesLanguage("en")]  
  
 // Version information for an assembly consists of the following four values:  
 //  
 //      Major Version  
 //      Minor Version  
 //      Build Number  
 //      Revision  
 //  
 // You can specify all the values or you can default the Build and Revision Numbers  
 // by using the '*' as shown below:  
 // [assembly:|AssemblyVersion("1.0.*")]  
 [assembly: AssemblyVersion("1.0.0.0")]  
 [assembly:|AssemblyFileVersion("1.0.0.0")]  
  
 </code>

====BufferSample.cs====

<code csharp>   
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class BufferSample : BaseSampleView  
     {  
         public const string SampleName = "Buffer";  
         private int bufferSize;  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             bufferSize = 0;  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             InMemoryFeatureLayer bufferedLayer = new InMemoryFeatureLayer();  
             bufferedLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(GeoColor.FromArgb(140, 255, 155, 13)));  
             bufferedLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("BufferedLayer", bufferedLayer);  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             InMemoryFeatureLayer bufferedLayer = (InMemoryFeatureLayer)layerOverlay.Layers["BufferedLayer"];  
  
             bufferSize += 15;  
             Feature bufferSourceFeature = sourceLayer.InternalFeatures[0].CloneDeep();  
             Feature bufferedFeature = bufferSourceFeature.Buffer(bufferSize, 8, BufferCapType.Butt, GeographyUnit.Meter, DistanceUnit.Meter);  
             bufferedLayer.InternalFeatures.Clear();  
             bufferedLayer.InternalFeatures.Add(bufferedFeature);  
  
             layerOverlay.Refresh();  
         }  
     }  
 }  
  
 </code>

====CenterPointSample.cs====

<code csharp>   
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class CenterPointSample : BaseSampleView  
     {  
         public const string SampleName = "CenterPoint";  
  
         private ManagedProj4Projection projection;  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             RectangleShape mapExtent = (RectangleShape)ExtentHelper.GetBoundingBoxOfItems(GeometrySource).CloneDeep();  
             mapExtent.ScaleUp(20);  
             MapView.CurrentExtent = mapExtent;  
  
             projection = new ManagedProj4Projection();  
             projection.InternalProjectionParametersString = ManagedProj4Projection.GetSphericalMercatorParametersString();  
             projection.ExternalProjectionParametersString = ManagedProj4Projection.GetLatLongParametersString();  
             projection.Open();  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             InMemoryFeatureLayer pointLayer = new InMemoryFeatureLayer();  
             pointLayer.Open();  
             pointLayer.Columns.Add(new FeatureSourceColumn("Type"));  
             pointLayer.Close();  
             pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolSize = 12;  
             pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolPen = new GeoPen(GeoColor.FromArgb(255, 255, 155, 13), 2);  
             pointLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.SymbolSolidBrush = new GeoSolidBrush(GeoColor.FromArgb(255, 255, 248, 172));  
             pointLayer.DrawingMarginPercentage = 100;  
             TextStyle textStyle = new TextStyle();  
             textStyle.TextColumnName = "Type";  
             textStyle.Font = new GeoFont("Arial", 15);  
             textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;  
             textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;  
             textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);  
             textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);  
             textStyle.PointPlacement = PointPlacement.LowerCenter;  
             textStyle.YOffsetInPixel = -8;  
             pointLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;  
             pointLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("PointLayer", pointLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer pointLayer = (InMemoryFeatureLayer)layerOverlay.Layers["PointLayer"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
  
             Feature feature = sourceLayer.InternalFeatures.FirstOrDefault();  
             pointLayer.Clear();  
             Feature centerFeature = new Feature(feature.GetBoundingBox().GetCenterPoint());  
             PointShape centerPoint = (PointShape)projection.ConvertToExternalProjection(centerFeature.CloneDeep()).GetShape();  
             centerFeature.ColumnValues["Type"] = string.Format("Center at Lon: {0:N4}, Lat: {1:N4}", centerPoint.X, centerPoint.Y);  
             pointLayer.InternalFeatures.Add(centerFeature);  
             Feature centroidFeature = new Feature(feature.GetShape().GetCenterPoint());  
             PointShape centroidPoint = (PointShape)projection.ConvertToExternalProjection(centroidFeature.CloneDeep()).GetShape();  
             centroidFeature.ColumnValues["Type"] = string.Format("Centroid at Lon: {0:N4}, Lat: {1:N4}", centroidPoint.X, centroidPoint.Y);  
             pointLayer.InternalFeatures.Add(centroidFeature);  
  
             layerOverlay.Refresh();  
         }  
     }  
 }  
  
 </code>

====ClipSample.cs====

<code csharp>   
 using System.Collections.ObjectModel;  
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class ClipSample : BaseSampleView  
     {  
         public const string SampleName = "Clip";  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(new GeoColor(160, 255, 248, 172)));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 1;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             foreach (Feature feature in GeometrySource.Skip(1))  
             {  
                 sourceLayer.InternalFeatures.Add(feature);  
             }  
  
             InMemoryFeatureLayer clippingLayer = new InMemoryFeatureLayer();  
             clippingLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             clippingLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             clippingLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.FromArgb(255, 255, 155, 13);  
             clippingLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             clippingLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("ClippingLayer", clippingLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             InMemoryFeatureLayer clipLayer = (InMemoryFeatureLayer)layerOverlay.Layers["ClippingLayer"];  
             Feature clippingFeature = clipLayer.InternalFeatures.FirstOrDefault();  
  
             if (clippingFeature != null)  
             {  
                 sourceLayer.Open();  
                 Collection<Feature> features = sourceLayer.QueryTools.GetFeaturesIntersecting(clippingFeature.GetShape(), ReturningColumnsType.AllColumns);  
                 sourceLayer.InternalFeatures.Clear();  
                 clipLayer.InternalFeatures.Clear();  
                 foreach (Feature feature in features)  
                 {  
                     sourceLayer.InternalFeatures.Add(feature.GetIntersection(clippingFeature));  
                 }  
             }  
  
             layerOverlay.Refresh();  
         }  
     }  
 }  
  
 </code>

====ConvexHullSample.cs====

<code csharp>   
 using System.Collections.ObjectModel;  
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class ConvexHullSample : BaseSampleView  
     {  
         public const string SampleName = "Convex Hull";  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.PointType = PointType.Bitmap;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle.Image = new GeoImage(SampleHelper.GetDataPath(@"fire.png"));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             foreach (Feature feature in GeometrySource)  
             {  
                 sourceLayer.InternalFeatures.Add(feature);  
             }  
  
             InMemoryFeatureLayer convexHullLayer = new InMemoryFeatureLayer();  
             convexHullLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             convexHullLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             convexHullLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             convexHullLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("ConvexHullLayer", convexHullLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             InMemoryFeatureLayer convexHullLayer = (InMemoryFeatureLayer)layerOverlay.Layers["ConvexHullLayer"];  
  
             sourceLayer.Open();  
             Collection<Feature> features = sourceLayer.FeatureSource.GetAllFeatures(ReturningColumnsType.NoColumns);  
  
             convexHullLayer.Clear();  
             MultipointShape multipointShape = new MultipointShape();  
             foreach (Feature feature in features.Skip(1))  
             {  
                 PointShape pointShape = (PointShape)feature.GetShape();  
                 multipointShape.Points.Add(pointShape);  
             }  
  
             RingShape convexHull = multipointShape.ConvexHull();  
             PolygonShape polygonShape = new PolygonShape(convexHull);  
             convexHullLayer.InternalFeatures.Add(new Feature(polygonShape));  
             convexHullLayer.InternalFeatures.Add(features.FirstOrDefault().GetConvexHull());  
  
             layerOverlay.Refresh();  
         }  
     }  
 }  
  
 </code>

====DifferenceSample.cs====

<code csharp>   
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class DifferenceSample : BaseSampleView  
     {  
         public const string SampleName = "Difference";  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             sourceLayer.InternalFeatures.Add("AreaShape1", GeometrySource[0]);  
             sourceLayer.InternalFeatures.Add("AreaShape2", GeometrySource[1]);  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
  
             if (sourceLayer.InternalFeatures.Count > 1)  
             {  
                 AreaBaseShape sourceShape = (AreaBaseShape)sourceLayer.InternalFeatures["AreaShape2"].GetShape();  
                 AreaBaseShape targetShape = (AreaBaseShape)sourceLayer.InternalFeatures["AreaShape1"].GetShape();  
                 AreaBaseShape resultShape = sourceShape.GetDifference(targetShape);  
  
                 sourceLayer.InternalFeatures.Clear();  
                 sourceLayer.InternalFeatures.Add(new Feature(resultShape.GetWellKnownBinary()));  
  
                 layerOverlay.Refresh();  
             }  
         }  
     }  
 }  
  
 </code>

====EnvelopSample.cs====

<code csharp>   
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class EnvelopSample : BaseSampleView  
     {  
         public const string SampleName = "Envelop Boundingbox";  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             sourceLayer.InternalFeatures.Add(GeometrySource.First());  
  
             InMemoryFeatureLayer boundingboxLayer = new InMemoryFeatureLayer();  
             boundingboxLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(new GeoColor(160, 255, 248, 172)));  
             boundingboxLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             boundingboxLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.FromArgb(255, 255, 155, 13);  
             boundingboxLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("BoundingboxLayer", boundingboxLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer boundingboxLayer = (InMemoryFeatureLayer)layerOverlay.Layers["BoundingboxLayer"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
  
             Feature sourceFeature = sourceLayer.InternalFeatures.First();  
             boundingboxLayer.InternalFeatures.Clear();  
             boundingboxLayer.InternalFeatures.Add(new Feature(sourceFeature.GetBoundingBox()));  
  
             layerOverlay.Refresh();  
         }  
     }  
 }  
  
 </code>

====GetAreaSample.cs====

<code csharp>   
 using System.Globalization;  
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
 using Xamarin.Forms;  
  
 namespace GeometricFunc  
 {  
     public class GetAreaSample : BaseSampleView  
     {  
         public const string SampleName = "GetArea";  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.Open();  
             sourceLayer.Columns.Add(new FeatureSourceColumn("Area"));  
  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
  
             TextStyle textStyle = new TextStyle();  
             textStyle.TextColumnName = "Area";  
             textStyle.Font = new GeoFont("Arial", 15);  
             textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;  
             textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;  
             textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);  
             textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);  
             textStyle.PointPlacement = PointPlacement.LowerCenter;  
             textStyle.YOffsetInPixel = -8;  
  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             sourceLayer.InternalFeatures.Add(GeometrySource.First());  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             Feature feature = sourceLayer.InternalFeatures.FirstOrDefault();  
             if (feature != null)  
             {  
                 AreaBaseShape areaShape = (AreaBaseShape)feature.GetShape();  
                 double metersArea = areaShape.GetArea(GeographyUnit.Meter, AreaUnit.SquareMeters);  
                 double hectaresArea = areaShape.GetArea(GeographyUnit.Meter, AreaUnit.Hectares);  
  
                 string areaMessage = string.Format(CultureInfo.InvariantCulture, "{0:N2} Hectares, \r\n {1:N2} Acres", metersArea, hectaresArea);  
                 feature.ColumnValues["Area"] = areaMessage;  
  
                 //Toast.MakeText(context, areaMessage, ToastLength.Long).Show();  
                 //MessagingCenter.Send<BaseSampleView, string>(this, "Alert", areaMessage);  
                 Application.Current.MainPage.DisplayAlert("Message", areaMessage, "OK");  
  
                 layerOverlay.Refresh();  
             }  
         }  
     }  
 }  
  
 </code>

====GetLengthSample.cs====

<code csharp>   
 using System.Globalization;  
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
 using Xamarin.Forms;  
  
 namespace GeometricFunc  
 {  
     public class GetLengthSample : BaseSampleView  
     {  
         public const string SampleName = "Get Length";  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.Open();  
             sourceLayer.Columns.Add(new FeatureSourceColumn("Length"));  
             sourceLayer.Close();  
  
             TextStyle textStyle = new TextStyle();  
             textStyle.TextColumnName = "Length";  
             textStyle.Font = new GeoFont("Arial", 15);  
             textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;  
             textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;  
             textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);  
             textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);  
  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.InnerPen.Brush = new GeoSolidBrush(GeoColor.FromArgb(180, 255, 155, 13));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             sourceLayer.InternalFeatures.Add(GeometrySource.First());  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.TileType = TileType.SingleTile;  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
  
             Feature firstFeature = sourceLayer.InternalFeatures.FirstOrDefault();  
             if (firstFeature != null)  
             {  
                 Feature feature = firstFeature.CloneDeep();  
                 LineBaseShape lineShape = (LineBaseShape)feature.GetShape();  
                 double length = lineShape.GetLength(GeographyUnit.Meter, DistanceUnit.Mile);  
                 string lengthContent = string.Format(CultureInfo.InvariantCulture, "Length is {0:N2} miles.", length);  
                 feature.ColumnValues["Length"] = lengthContent;  
  
                 sourceLayer.InternalFeatures.Clear();  
                 sourceLayer.InternalFeatures.Add(feature);  
                 Application.Current.MainPage.DisplayAlert("Message", lengthContent, "OK");  
  
                 layerOverlay.Refresh();  
             }  
  
         }  
     }  
 }  
  
 </code>

====GetShortestLineSample.cs====

<code csharp>   
 using System.Globalization;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class GetShortestLineSample : BaseSampleView  
     {  
         public const string SampleName = "GetShortestLine To";  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             RectangleShape mapExtent = (RectangleShape)ExtentHelper.GetBoundingBoxOfItems(GeometrySource).CloneDeep();  
             mapExtent.ScaleUp(20);  
             MapView.CurrentExtent = mapExtent;  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             sourceLayer.InternalFeatures.Add("AreaShape1", GeometrySource[0]);  
             sourceLayer.InternalFeatures.Add("AreaShape2", GeometrySource[1]);  
  
             InMemoryFeatureLayer shortestLineLayer = new InMemoryFeatureLayer();  
             shortestLineLayer.Open();  
             shortestLineLayer.Columns.Add(new FeatureSourceColumn("Distance"));  
  
             TextStyle textStyle = new TextStyle();  
             textStyle.TextColumnName = "Distance";  
             textStyle.Font = new GeoFont("Arial", 15);  
             textStyle.DuplicateRule = LabelDuplicateRule.UnlimitedDuplicateLabels;  
             textStyle.OverlappingRule = LabelOverlappingRule.AllowOverlapping;  
             textStyle.TextSolidBrush = new GeoSolidBrush(GeoColor.StandardColors.Black);  
             textStyle.HaloPen = new GeoPen(new GeoSolidBrush(GeoColor.StandardColors.White), 1);  
             textStyle.PointPlacement = PointPlacement.LowerCenter;  
             textStyle.YOffsetInPixel = -8;  
  
             shortestLineLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = textStyle;  
             shortestLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen.Width = 5;  
             shortestLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen.Color = GeoColor.FromArgb(180, 255, 155, 13);  
             shortestLineLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("ShortestLineLayer", shortestLineLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             InMemoryFeatureLayer shortestLineLayer = (InMemoryFeatureLayer)layerOverlay.Layers["ShortestLineLayer"];  
  
             BaseShape areaShape1 = sourceLayer.InternalFeatures["AreaShape1"].GetShape();  
             BaseShape areaShape2 = sourceLayer.InternalFeatures["AreaShape2"].GetShape();  
             MultilineShape multiLineShape = areaShape1.GetShortestLineTo(areaShape2, GeographyUnit.Meter);  
             Feature feature = new Feature(multiLineShape.GetWellKnownBinary());  
             feature.ColumnValues["Distance"] = string.Format(CultureInfo.InvariantCulture, "Distance is {0:N2} miles.", multiLineShape.GetLength(GeographyUnit.Meter, DistanceUnit.Mile));  
             shortestLineLayer.InternalFeatures.Clear();  
             shortestLineLayer.InternalFeatures.Add(feature);  
  
             layerOverlay.Refresh();  
         }  
     }  
 }  
  
 </code>

====LineOnLineSample.cs====

<code csharp>   
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class LineOnLineSample : BaseSampleView  
     {  
         public const string SampleName = "Line on Line";  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.InnerPen.Brush = new GeoSolidBrush(GeoColor.FromArgb(180, 255, 155, 13));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultPointStyle = PointStyles.CreateSimplePointStyle(PointSymbolType.Circle, GeoColor.StandardColors.Transparent, GeoColor.StandardColors.Black, 18);  
             foreach (var feature in GeometrySource)  
             {  
                 sourceLayer.InternalFeatures.Add(feature);  
             }  
  
             InMemoryFeatureLayer lineOnLineLayer = new InMemoryFeatureLayer();  
             lineOnLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.LocalRoad1;  
             lineOnLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.InnerPen.Brush = new GeoSolidBrush(GeoColor.StandardColors.Blue);  
             lineOnLineLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle.OuterPen.Brush = new GeoSolidBrush(GeoColor.StandardColors.Red);  
             lineOnLineLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             layerOverlay.Layers.Add("LineOnLineLayer", lineOnLineLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer lineOnLineLayer = (InMemoryFeatureLayer)layerOverlay.Layers["LineOnLineLayer"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
  
             Feature firstFeature = sourceLayer.InternalFeatures.FirstOrDefault();  
             if (firstFeature != null)  
             {  
                 LineShape lineShape = (LineShape)firstFeature.GetShape();  
                 lineOnLineLayer.InternalFeatures.Clear();  
  
                 LineBaseShape resultLine = lineShape.GetLineOnALine(StartingPoint.FirstPoint, 80, 450, GeographyUnit.Meter, DistanceUnit.Meter);  
                 lineOnLineLayer.InternalFeatures.Add(new Feature(resultLine));  
                 layerOverlay.Refresh();  
             }  
         }  
     }  
 }  
  
 </code>

====RotateSample.cs====

<code csharp>   
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class RotateSample : BaseSampleView  
     {  
         public const string SampleName = "Rotate";  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             sourceLayer.InternalFeatures.Add(GeometrySource.FirstOrDefault());  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
  
             Feature sourceFeature = sourceLayer.InternalFeatures.FirstOrDefault();  
             if (sourceFeature != null && sourceFeature.GetShape().CanRotate)  
             {  
                 PointShape center = sourceFeature.GetBoundingBox().GetCenterPoint();  
                 BaseShape rotatedShape = BaseShape.Rotate(sourceFeature.GetShape(), center, 22.5f);  
                 sourceLayer.InternalFeatures.Clear();  
                 sourceLayer.InternalFeatures.Add(new Feature(rotatedShape));  
                 layerOverlay.Refresh();  
             }  
         }  
     }  
 }  
  
 </code>

====SampleListPage.xaml.cs====

<code csharp>   
 using System;  
 using System.Collections.ObjectModel;  
 using Xamarin.Forms;  
  
 namespace GeometricFunc  
 {  
     public partial class SampleListPage : ContentPage  
     {  
         private string title;  
         private SampleItem selectedSample;  
         private ObservableCollection<SampleItem> samples;  
         private Command openHelpUriCommand;  
  
         public event EventHandler SelectedSampleChanged;  
  
         public SampleListPage()  
         {  
             InitializeComponent();  
             samples = new ObservableCollection<SampleItem>();  
  
             samples.Add(new SampleItem("Union", "union", typeof(UnionSample)));  
             samples.Add(new SampleItem("Difference", "difference", typeof(DifferenceSample)));  
             samples.Add(new SampleItem("Buffer", "buffer", typeof(BufferSample)));  
             samples.Add(new SampleItem("Scale", "scale", typeof(ScaleSample)));  
             samples.Add(new SampleItem("Rotate", "rotate", typeof(RotateSample)));  
             samples.Add(new SampleItem("CenterPoint", "centerPoint", typeof(CenterPointSample)));  
             samples.Add(new SampleItem("GetArea", "getArea", typeof(GetAreaSample)));  
             samples.Add(new SampleItem("Simplify", "simplify", typeof(SimplifySample)));  
             samples.Add(new SampleItem("GetShortestLine To", "shortestLine", typeof(GetShortestLineSample)));  
             samples.Add(new SampleItem("Get Length", "getLength", typeof(GetLengthSample)));  
             samples.Add(new SampleItem("Line on Line", "lineOnLine", typeof(LineOnLineSample)));  
             samples.Add(new SampleItem("Clip", "clip", typeof(ClipSample)));  
             samples.Add(new SampleItem("Convex Hull", "convexHull", typeof(ConvexHullSample)));  
             samples.Add(new SampleItem("Envelop Boundingbox", "bbox", typeof(EnvelopSample)));  
             samples.Add(new SampleItem("Snapping", "snapGps", typeof(SnapGPSSample)));  
  
             BindingContext = this;  
         }  
  
         public SampleItem SelectedSample  
         {  
             get  
             {  
                 return selectedSample;  
             }  
             set  
             {  
                 if (selectedSample != value)  
                 {  
                     selectedSample = value;  
                     OnPropertyChanged("SelectedSample");  
                     OnSelectedSampleChanged();  
                 }  
             }  
         }  
  
         public ObservableCollection<SampleItem> Samples  
         {  
             get { return samples; }  
         }  
  
         public Command OpenHelpUriCommand  
         {  
             get  
             {  
                 openHelpUriCommand = openHelpUriCommand ?? new Command(() => Device.OpenUri(new Uri("http://www.thinkgeo.com")));  
                 return openHelpUriCommand;  
             }  
         }  
  
         protected virtual void OnSelectedSampleChanged()  
         {  
             EventHandler handler = SelectedSampleChanged;  
             if (handler != null)  
             {  
                 handler(this, new EventArgs());  
             }  
         }  
     }  
 }  
  
 </code>

====ScaleSample.cs====

<code csharp>   
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class ScaleSample : BaseSampleView  
     {  
         public const string SampleName = "Scale";  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             Feature sourceFeature = GeometrySource.First();  
             sourceLayer.InternalFeatures.Add(sourceFeature.Id, sourceFeature);  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
             Feature sourceFeature = sourceLayer.InternalFeatures.First();  
  
             sourceLayer.Open();  
             sourceLayer.EditTools.BeginTransaction();  
             sourceLayer.EditTools.ScaleUp(sourceFeature.Id, 10);  
             sourceLayer.EditTools.CommitTransaction();  
  
             layerOverlay.Refresh();  
         }  
     }  
 }  
  
 </code>

====SimplifySample.cs====

<code csharp>   
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class SimplifySample : BaseSampleView  
     {  
         public const string SampleName = "Simplify";  
         private static readonly double simplifyTolerence = 30;  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             Feature feature = GeometrySource.FirstOrDefault();  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.StandardColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             sourceLayer.InternalFeatures.Add(feature);  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
  
             AreaBaseShape sourceShape = (AreaBaseShape)sourceLayer.InternalFeatures.FirstOrDefault().GetShape();  
             SimplificationType simplificationType = SimplificationType.DouglasPeucker;  
  
             MultipolygonShape multipolygonShape = sourceShape.Simplify(GeographyUnit.Meter, simplifyTolerence, DistanceUnit.Meter, simplificationType);  
             sourceLayer.InternalFeatures.Clear();  
             sourceLayer.InternalFeatures.Add(new Feature(multipolygonShape));  
  
             layerOverlay.Refresh();  
         }  
     }  
 }  
  
 </code>

====SnapGPSSample.cs====

<code csharp>   
 using System.Collections.Generic;  
 using System.Collections.ObjectModel;  
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class SnapGPSSample : BaseSampleView  
     {  
         public const string SampleName = "Snapping";  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         private InMemoryFeatureLayer inProcessLayer;  
         private InMemoryFeatureLayer resultLayer;  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             inProcessLayer = new InMemoryFeatureLayer();  
             resultLayer = new InMemoryFeatureLayer();  
  
             inProcessLayer.Open();  
             inProcessLayer.Columns.Add(new FeatureSourceColumn("Name", "character", 100));  
  
             resultLayer.Open();  
             resultLayer.Columns.Add(new FeatureSourceColumn("Name", "character", 100));  
  
             InitializeStyle();  
  
             foreach (var feature in GeometrySource)  
             {  
                 inProcessLayer.InternalFeatures.Add(feature);  
             }  
  
             CollectVertices(inProcessLayer.InternalFeatures.Skip(1).ToArray(), resultLayer);  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", inProcessLayer);  
             layerOverlay.Layers.Add("PointLayer", resultLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             resultLayer.InternalFeatures.Clear();  
             if (resultLayer.InternalFeatures.Count == 0)  
             {  
                 inProcessLayer.IsVisible = false;  
  
                 Feature multilineFeature = inProcessLayer.InternalFeatures[0];  
                 MultilineShape multilineShape = (MultilineShape)multilineFeature.GetShape();  
                 Feature[] allFeatures = { inProcessLayer.InternalFeatures[1] };  
                 double tolerance = 100;  
  
                 Collection<Feature> matchFeatures = new Collection<Feature>();  
                 foreach (var item in allFeatures)  
                 {  
                     double tempDistance = multilineShape.GetShortestLineTo(item, GeographyUnit.Meter).GetLength(GeographyUnit.Meter, DistanceUnit.Feet);  
                     if (tempDistance < tolerance)  
                     {  
                         matchFeatures.Add(item);  
                     }  
                 }  
  
                 resultLayer.InternalFeatures.Add(multilineFeature);  
                 foreach (var feature in matchFeatures)  
                 {  
                     Collection<Vertex> vertices = new Collection<Vertex>();  
                     PointShape resultShape = multilineShape.GetClosestPointTo(feature, GeographyUnit.Meter);  
                     MultilineShape tempMultilineShape = feature.GetShape() as MultilineShape;  
                     if (tempMultilineShape != null)  
                     {  
                         double offsetX = resultShape.X - tempMultilineShape.Lines[0].Vertices[0].X;  
                         double offsetY = resultShape.Y - tempMultilineShape.Lines[0].Vertices[0].Y;  
                         vertices.Add(new Vertex(resultShape));  
  
                         double x = offsetX + tempMultilineShape.Lines[0].Vertices[1].X;  
                         double y = offsetY + tempMultilineShape.Lines[0].Vertices[1].Y;  
                         vertices.Add(new Vertex(x, y));  
                     }  
  
                     resultLayer.InternalFeatures.Add(new Feature(new MultilineShape(new[] { new LineShape(vertices) })));  
                 }  
  
                 foreach (var feature in allFeatures)  
                 {  
                     if (!matchFeatures.Contains(feature))  
                     {  
                         resultLayer.InternalFeatures.Add(feature);  
                     }  
                 }  
  
                 CollectVertices(resultLayer.InternalFeatures.Skip(1).ToArray(), resultLayer);  
             }  
  
             layerOverlay.Refresh();  
         }  
  
         private static void CollectVertices(IEnumerable<Feature> features, InMemoryFeatureLayer featureLayer)  
         {  
             lock (features)  
             {  
                 foreach (var multilineShape in features.Select(f => f.GetShape()).OfType<MultilineShape>())  
                 {  
                     foreach (var vertex in multilineShape.Lines.SelectMany(l => l.Vertices))  
                     {  
                         EllipseShape ellipseShape = new EllipseShape(new PointShape(vertex), 30);  
                         featureLayer.InternalFeatures.Add(new Feature(ellipseShape));  
                     }  
                 }  
             }  
         }  
  
         private void InitializeStyle()  
         {  
             GeoColor semiTransparentOrange = GeoColor.FromArgb(140, 255, 155, 13);  
  
             inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.StandardColors.Transparent, GeoColor.StandardColors.Black);  
             inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(semiTransparentOrange, 3, false);  
             inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("Name", "Arial", 9, DrawingFontStyles.Regular, GeoColor.StandardColors.Black);  
             inProcessLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             resultLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = inProcessLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle;  
             resultLayer.ZoomLevelSet.ZoomLevel01.DefaultLineStyle = LineStyles.CreateSimpleLineStyle(semiTransparentOrange, 4, false);  
             resultLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
         }  
     }  
 }  
  
 </code>

====UnionSample.cs====

<code csharp>   
 using System.Collections.Generic;  
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
  
 namespace GeometricFunc  
 {  
     public class UnionSample : BaseSampleView  
     {  
         public const string SampleName = "Union";  
  
         public override string Name  
         {  
             get { return SampleName; }  
         }  
  
         protected override void LoadMap()  
         {  
             MapView.MapUnit = GeographyUnit.Meter;  
             MapView.CurrentExtent = GetBoundingBox();  
  
             InMemoryFeatureLayer sourceLayer = new InMemoryFeatureLayer();  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = new AreaStyle(new GeoSolidBrush(BrushColor));  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Width = 3;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle.OutlinePen.Color = GeoColor.SimpleColors.Black;  
             sourceLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
  
             foreach (Feature feature in GeometrySource)  
             {  
                 sourceLayer.InternalFeatures.Add(feature);  
             }  
  
             LayerOverlay layerOverlay = new LayerOverlay();  
             layerOverlay.Layers.Add("SourceLayer", sourceLayer);  
             MapView.Overlays.Add("LayerOverlay", layerOverlay);  
         }  
  
         protected override void ExecuteSample()  
         {  
             LayerOverlay layerOverlay = (LayerOverlay)MapView.Overlays["LayerOverlay"];  
             InMemoryFeatureLayer sourceLayer = (InMemoryFeatureLayer)layerOverlay.Layers["SourceLayer"];  
  
             if (sourceLayer.InternalFeatures.Count > 1)  
             {  
                 IEnumerable<AreaBaseShape> areaBaseShapes = sourceLayer.InternalFeatures.Select(f => f.GetShape()).OfType<AreaBaseShape>();  
  
                 AreaBaseShape unionedAreaBaseShape = AreaBaseShape.Union(areaBaseShapes);  
                 sourceLayer.InternalFeatures.Clear();  
                 sourceLayer.InternalFeatures.Add(new Feature(unionedAreaBaseShape));  
  
                 layerOverlay.Refresh();  
             }  
         }  
     }  
 }  
  
 </code>

====BaseSampleView.cs====

<code csharp>   
 using System;  
 using System.IO;  
 using System.Linq;  
 using System.Collections.ObjectModel;  
 using System.Reflection;  
 using System.Xml.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.FormsEdition;  
 using Xamarin.Forms;  
  
 namespace GeometricFunc  
 {  
     public abstract class BaseSampleView : ContentView, IDisposable  
     {  
         protected static readonly GeoColor BrushColor = GeoColor.FromArgb(100, 0, 147, 221);  
  
         private MapView mapView;  
         private ToolbarItem sampleToolbarItem;  
         private Collection<Feature> geometrySource;  
  
         public BaseSampleView()  
         {  
             mapView = new MapView();  
             mapView.MapUnit = GeographyUnit.Meter;  
             mapView.CurrentExtent = new RectangleShape(-30, 10, 10, -10);  
  
             Content = new Grid { Children = { mapView } };  
  
             var assembly = typeof(BaseSampleView).GetTypeInfo().Assembly;  
             Stream stream = assembly.GetManifestResourceStream("GeometricFunc.AppData.GeometricFunctions.xml");  
             XDocument xdoc = XDocument.Load(stream);  
             XElement selectSampleElement = xdoc.Root.Elements().FirstOrDefault(e => e.Attribute("Name").Value == Name);  
             XElement geometrySourceElement = selectSampleElement.Element("GeometrySource");  
             foreach (var featureWktElement in geometrySourceElement.Elements())  
             {  
                 if (!string.IsNullOrEmpty(featureWktElement.Value))  
                 {  
                     GeometrySource.Add(new Feature(featureWktElement.Value));  
                 }  
             }  
  
             WorldMapKitOverlay worldOverlay = new WorldMapKitOverlay();  
             worldOverlay.Projection = WorldMapKitProjection.SphericalMercator;  
             mapView.Overlays.Insert(0, "WMK", worldOverlay);  
             LoadMap();  
         }  
  
         public abstract string Name { get; }  
  
         public MapView MapView  
         {  
             get { return mapView; }  
         }  
  
         public Collection<Feature> GeometrySource  
         {  
             get { return geometrySource ?? (geometrySource = new Collection<Feature>()); }  
         }  
  
         public virtual ToolbarItem SampleToolbarItem  
         {  
             get  
             {  
                 if (sampleToolbarItem == null)  
                 {  
                     sampleToolbarItem = new ToolbarItem { Text = "GO", Name = "GO" };  
                     sampleToolbarItem.Clicked += delegate { ExecuteSample(); };  
                 }  
  
                 return sampleToolbarItem;  
             }  
         }  
  
         protected virtual RectangleShape GetBoundingBox()  
         {  
             RectangleShape mapExtent = (RectangleShape)ExtentHelper.GetBoundingBoxOfItems(GeometrySource).CloneDeep();  
             mapExtent.ScaleUp(100);  
             return mapExtent;  
         }  
  
         protected abstract void ExecuteSample();  
  
         protected abstract void LoadMap();  
  
         ~BaseSampleView()  
         {  
             Dispose(false);  
         }  
  
         public void Dispose()  
         {  
             Dispose(true);  
             GC.SuppressFinalize(this);  
         }  
  
         protected virtual void Dispose(bool disposing)  
         {  
             if (disposing)  
             {  
                 mapView.Dispose();  
             }  
         }  
     }  
 }  
  
 </code>

====SampleItem.cs====

<code csharp>   
 using System;  
 using Xamarin.Forms;  
  
 namespace GeometricFunc  
 {  
     public class SampleItem  
     {  
         private string name;  
         private ImageSource icon;  
         private Type classType;  
  
         public SampleItem(string name, string iconPathFilename, Type classType)  
         {  
             this.name = name;  
             this.classType = classType;  
             this.icon = new FileImageSource { File = iconPathFilename };  
         }  
  
         public string Name  
         {  
             get { return name; }  
             set { name = value; }  
         }  
  
         public ImageSource Icon  
         {  
             get { return icon; }  
             set { icon = value; }  
         }  
  
         public Type ClassType  
         {  
             get { return classType; }  
             set { classType = value; }  
         }  
     }  
 }  
  
 </code>

====SampleHelper.cs====

<code csharp>   
 using System.IO;  
 using Xamarin.Forms;  
  
 namespace GeometricFunc  
 {  
     public static class SampleHelper  
     {  
         public static readonly string SampleDataDictionary = Device.OnPlatform(@"AppData/", @"mnt/sdcard/MapSuiteSampleData/GeometricFunc", string.Empty);  
  
         public static string GetDataPath(string fileName)  
         {  
             return Path.Combine(SampleDataDictionary, fileName);  
         }  
     }  
 }  
  
 </code>