using System;  
 using System.Collections.ObjectModel;  
 using System.Configuration;  
 using System.Globalization;  
 using System.Linq;  
 using System.Web.Mvc;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.MvcEdition;  
 using ThinkGeo.MapSuite.Routing;  
 
 namespace ThinkGeo.MapSuite.RoutingExamples.Controllers  
 {  
     public class DefaultController : Controller  
     {  
         // GET: /Default/  
         private static readonly string roadColumnName = "FULL_STREE";  
 
         private static Collection<string> avoidableFeatureIds;  
 
         private static Feature newBarrierFeature;  
         private static ShapeFileFeatureLayer routingShapeFile;  
 
         public ActionResult Index()  
         {  
             routingShapeFile = new ShapeFileFeatureLayer(Server.MapPath(ConfigurationManager.AppSettings["austinStreetShapeFile"]));  
             avoidableFeatureIds = new Collection<string>();  
 
             // Initialize map  
             Map map = InitializeMap();  
 
             return View(map);  
         }  
 
         [MapActionFilter]  
         public ActionResult addRouteAddresses(Map map, GeoCollection<object> args)  
         {  
             double x = double.Parse(args["x"].ToString(), CultureInfo.InvariantCulture);  
             double y = double.Parse(args["y"].ToString(), CultureInfo.InvariantCulture);  
             PointShape clickedPoint = new PointShape(x, y);  
 
             if (CheckPointIsValid(clickedPoint, map))  
             {  
                 RouteStopType stopType = GetRouteStopType(args["type"].ToString());  
 
                 // Get RouteLayer  
                 LayerOverlay routingOverlay = (LayerOverlay)map.CustomOverlays["RoutingOverlay"];  
                 RoutingLayer routingLayer = (RoutingLayer)routingOverlay.Layers.FirstOrDefault();  
 
                 switch (stopType)  
                 {  
                     case RouteStopType.Start:  
                         routingLayer.StartPoint = clickedPoint;  
                         break;  
                     case RouteStopType.End:  
                         routingLayer.EndPoint = clickedPoint;  
                         break;  
                     case RouteStopType.Stop:  
                         routingLayer.StopPoints.Add(clickedPoint);  
                         break;  
                 }  
                 routingOverlay.Redraw();  
 
                 return PartialView("RouteStops", routingLayer);  
             }  
             return new ContentResult();  
         }  
 
         [MapActionFilter]  
         public bool ChangeRouteAddress(Map map, GeoCollection<object> args)  
         {  
             double x = double.Parse(args["x"].ToString(), CultureInfo.InvariantCulture);  
             double y = double.Parse(args["y"].ToString(), CultureInfo.InvariantCulture);  
             PointShape clickedPoint = new PointShape(x, y);  
 
             if (CheckPointIsValid(clickedPoint, map))  
             {  
                 RouteStopType stopType = GetRouteStopType(args["type"].ToString());  
 
                 // Get RouteLayer  
                 LayerOverlay routingOverlay = (LayerOverlay)map.CustomOverlays["RoutingOverlay"];  
                 RoutingLayer routingLayer = (RoutingLayer)routingOverlay.Layers.FirstOrDefault();  
 
                 switch (stopType)  
                 {  
                     case RouteStopType.Start:  
                         routingLayer.StartPoint = clickedPoint;  
                         break;  
                     case RouteStopType.End:  
                         routingLayer.EndPoint = clickedPoint;  
                         break;  
                     case RouteStopType.Stop:  
                         routingLayer.StopPoints.Add(clickedPoint);  
                         break;  
                 }  
                 routingOverlay.Redraw();  
 
                 return true;  
             }  
             return false;  
         }  
 
         [MapActionFilter]  
         public ActionResult RemoveRouteAddresses(Map map, GeoCollection<object> args)  
         {  
             LayerOverlay routingOverlay = (LayerOverlay)map.CustomOverlays["RoutingOverlay"];  
             RoutingLayer routingLayer = (RoutingLayer)routingOverlay.Layers.FirstOrDefault();  
 
             int removedIndex = Convert.ToInt32(args[0].ToString());  
             int stopPointsCount = routingLayer.StopPoints.Count;  
             for (int i = 0; i < stopPointsCount; i++)  
             {  
                 if (i == removedIndex - 1)  
                 {  
                     routingLayer.StopPoints.RemoveAt(i);  
                 }  
             }  
 
             routingLayer.Routes.Clear();  
             routingOverlay.Redraw();  
 
             return PartialView("RouteStops", routingLayer);  
         }  
 
         [MapActionFilter]  
         public ActionResult ClearAll(Map map, GeoCollection<object> args)  
         {  
             var routingOverlay = (LayerOverlay)map.CustomOverlays["RoutingOverlay"];  
             var routingLayer = (RoutingLayer)routingOverlay.Layers.FirstOrDefault();  
 
             if (routingLayer != null)  
             {  
                 routingLayer.StartPoint = null;  
                 routingLayer.EndPoint = null;  
                 routingLayer.StopPoints.Clear();  
                 routingLayer.Routes.Clear();  
 
                 routingOverlay.Redraw();  
             }  
 
             ClearAllBarriers(map, null);  
 
             return PartialView("RouteStops", routingLayer);  
         }  
 
         [MapActionFilter]  
         public void ClearAllBarriers(Map map, GeoCollection<object> args)  
         {  
             LayerOverlay routingOverlay = (LayerOverlay)map.CustomOverlays["RoutingOverlay"];  
             InMemoryFeatureLayer barrierLayer = (InMemoryFeatureLayer)routingOverlay.Layers["BarrierLayer"];  
             barrierLayer.InternalFeatures.Clear();  
             avoidableFeatureIds.Clear();  
             routingOverlay.Redraw();  
 
             map.EditOverlay.Features.Clear();  
             map.EditOverlay.TrackMode = TrackMode.None;  
         }  
 
         [MapActionFilter]  
         public void UndoDrawnBarrier(Map map, GeoCollection<object> args)  
         {  
             if (newBarrierFeature != null)  
             {  
                 LayerOverlay routingOverlay = (LayerOverlay)map.CustomOverlays["RoutingOverlay"];  
                 InMemoryFeatureLayer barrierLayer = (InMemoryFeatureLayer)routingOverlay.Layers["BarrierLayer"];  
                 barrierLayer.InternalFeatures.Remove(newBarrierFeature);  
                 newBarrierFeature = null;  
 
                 avoidableFeatureIds.Clear();  
                 foreach (Feature feature in barrierLayer.InternalFeatures)  
                 {  
                     BaseShape barrierShape = feature.GetShape();  
 
                     routingShapeFile.Open();  
                     Collection<Feature> features = routingShapeFile.FeatureSource.GetFeaturesWithinDistanceOf(barrierShape, map.MapUnit, DistanceUnit.Meter, 1, ReturningColumnsType.NoColumns);  
                     routingShapeFile.Close();  
 
                     foreach (Feature avoidableFeature in features)  
                     {  
                         avoidableFeatureIds.Add(avoidableFeature.Id);  
                     }  
                 }  
 
                 routingOverlay.Redraw();  
             }  
         }  
 
         [MapActionFilter]  
         public void SwithStartEndPoint(Map map, GeoCollection<object> args)  
         {  
             LayerOverlay routingOverlay = (LayerOverlay)map.CustomOverlays["RoutingOverlay"];  
             RoutingLayer routingLayer = (RoutingLayer)routingOverlay.Layers.FirstOrDefault();  
 
             PointShape end = routingLayer.StartPoint;  
             routingLayer.StartPoint = routingLayer.EndPoint;  
             routingLayer.EndPoint = end;  
             routingLayer.Routes.Clear();  
 
             routingOverlay.Redraw();  
         }  
 
         [MapActionFilter]  
         public PartialViewResult RouteDirections(Map map, GeoCollection<object> args)  
         {  
             LayerOverlay routingOverlay = (LayerOverlay)map.CustomOverlays["RoutingOverlay"];  
             RoutingLayer routingLayer = (RoutingLayer)routingOverlay.Layers.FirstOrDefault();  
 
             if (routingLayer == null || routingLayer.StartPoint == null || routingLayer.EndPoint == null)  
                 return null;  
 
             string unit = args[1].ToString();  
             DistanceUnit distanceUnit = unit.Equals("Miles") ? DistanceUnit.Mile : DistanceUnit.Kilometer;  
             string rtgFilePathName = args["routeMode"].ToString() == "true" ? ConfigurationManager.AppSettings["rtgShortestFile"] : ConfigurationManager.AppSettings["rtgFastestFile"];  
 
             RoutingEngine routingEngine = new RoutingEngine(new RtgRoutingSource(Server.MapPath(rtgFilePathName)), routingShapeFile.FeatureSource);  
             InMemoryFeatureLayer barrierLayer = (InMemoryFeatureLayer)routingOverlay.Layers["BarrierLayer"];  
             RoutePathAndDirection routePathAndDirection = new RoutePathAndDirection(routingEngine, routingLayer.StartPoint, routingLayer.EndPoint, barrierLayer.FeatureSource, avoidableFeatureIds, routingLayer.StopPoints);  
 
             // Get the routes.  
             RoutingResult result = routePathAndDirection.GetRoute();  
 
             // Refresh the route result.  
             routingLayer.Routes.Clear();  
             routingLayer.Routes.Add(result.Route);  
 
             Collection<RouteDirectionModel> models = new Collection<RouteDirectionModel>();  
 
             for (int i = 0; i < result.RouteSegments.Count; i++)  
             {  
                 RouteDirectionModel routeDirection = new RouteDirectionModel(result.RouteSegments[i], result.Features[i], roadColumnName, map.MapUnit, distanceUnit);  
                 models.Add(routeDirection);  
             }  
             routingOverlay.Redraw();  
 
             ViewData["tableRouteDirections"] = models;  
 
             // Update the scale bar unit.  
             ScaleBarAdornmentLayer scaleLayer = (ScaleBarAdornmentLayer)map.AdornmentOverlay.Layers["scaleBarAdornmentLayer"];  
             scaleLayer.UnitFamily = unit.Equals("Miles") ? UnitSystem.Imperial : UnitSystem.Metric;  
 
             return PartialView("RouteDirections");  
         }  
 
         [MapActionFilter]  
         public void ProcessTrackFeatures(Map map, GeoCollection<object> args)  
         {  
             LayerOverlay routingOverlay = (LayerOverlay)map.CustomOverlays["RoutingOverlay"];  
             InMemoryFeatureLayer barrierLayer = (InMemoryFeatureLayer)routingOverlay.Layers["BarrierLayer"];  
 
             Feature trackFeature = Feature.CreateFeatureFromWellKnownData(args.Last().ToString());  
             if (trackFeature != null)  
             {  
                 trackFeature.ColumnValues["Restricted"] = "Obstacle";  
                 barrierLayer.InternalFeatures.Add(trackFeature);  
                 newBarrierFeature = trackFeature;  
             }  
 
             avoidableFeatureIds.Clear();  
             foreach (Feature feature in barrierLayer.InternalFeatures)  
             {  
                 BaseShape barrierShape = feature.GetShape();  
 
                 routingShapeFile.Open();  
                 Collection<Feature> features = routingShapeFile.FeatureSource.GetFeaturesWithinDistanceOf(barrierShape, map.MapUnit, DistanceUnit.Meter, 1, ReturningColumnsType.NoColumns);  
                 routingShapeFile.Close();  
 
                 foreach (Feature avoidableFeature in features)  
                 {  
                     avoidableFeatureIds.Add(avoidableFeature.Id);  
                 }  
             }  
 
             routingOverlay.Redraw();  
         }  
 
 
         private RouteStopType GetRouteStopType(string stopValue)  
         {  
             RouteStopType stopType = RouteStopType.Stop;  
             switch (stopValue)  
             {  
                 case "Directions from here":  
                 case "startPoint":  
                     stopType = RouteStopType.Start;  
                     break;  
                 case "Directions to here":  
                 case "endPoint":  
                     stopType = RouteStopType.End;  
                     break;  
                 case "Add to route":  
                 case "stopPoint":  
                 default: break;  
             }  
 
             return stopType;  
         }  
 
         private bool CheckPointIsValid(PointShape point, Map map)  
         {  
             LayerOverlay layerOverlay = map.CustomOverlays["AustinBoundaryOverlay"] as LayerOverlay;  
             ShapeFileFeatureLayer layer = layerOverlay.Layers["RestrictedLayer"] as ShapeFileFeatureLayer;  
 
             layer.Open();  
             Collection<Feature> features = layer.QueryTools.GetFeaturesContaining(point, ReturningColumnsType.NoColumns);  
             layer.Close();  
 
             if (features.Count > 0)  
             {  
                 return true;  
             }  
             else  
             {  
                 return false;  
             }  
         }  
 
         public Map InitializeMap()  
         {  
             Map map = new Map("Map1");  
             map.Width = new System.Web.UI.WebControls.Unit(100, System.Web.UI.WebControls.UnitType.Percentage);  
             map.Height = new System.Web.UI.WebControls.Unit(100, System.Web.UI.WebControls.UnitType.Percentage);  
             map.MapTools.Logo.Enabled = true;  
             map.MapUnit = GeographyUnit.DecimalDegree;  
 
             AddOverlays(map);  
             AddContextMenus(map);  
 
             map.OnClientTrackShapeFinished = "trackShapeFinished";  
             map.CurrentExtent = new RectangleShape(-97.783553154785, 30.362039937378, -97.680175654785, 30.229261310914);  
 
             return map;  
         }  
 
         private void AddOverlays(Map map)  
         {  
             // Use World Map Kit as base overlay  
             WorldMapKitWmsWebOverlay worldMapKitOverlay = new WorldMapKitWmsWebOverlay("WorldMapKit Map");  
             map.CustomOverlays.Add(worldMapKitOverlay);  
 
             // Add routing layer and barrier layer  
             LayerOverlay routingOverlay = new LayerOverlay("RoutingOverlay");  
             map.CustomOverlays.Add(routingOverlay);  
 
             RoutingLayer routingLayer = new RoutingLayer();  
             routingLayer.StartPointStyle = new PointStyle(new GeoImage(Server.MapPath("~/Content/Images/start.png")));  
             routingLayer.EndPointStyle = new PointStyle(new GeoImage(Server.MapPath("~/Content/Images/end.png")));  
             routingLayer.StopPointStyle = new PointStyle(new GeoImage(Server.MapPath("~/Content/Images/stop.png"))) { YOffsetInPixel = -10 };  
             routingLayer.StopTextStyle.TextSolidBrush.Color = GeoColor.StandardColors.White;  
             routingLayer.StopTextStyle.Font = new GeoFont("Arial", 10);  
             routingLayer.XOffsetInPixelOfStopOrder = -3;  
             routingLayer.YOffsetInPixelOfStopOrder = 14;  
             routingOverlay.Layers.Add("RoutingLayer", routingLayer);  
 
             InMemoryFeatureLayer barrierLayer = new InMemoryFeatureLayer(new Collection<FeatureSourceColumn>() { new FeatureSourceColumn("Restricted", "Charater", 10) }, new BaseShape[] { });  
             barrierLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = AreaStyles.CreateSimpleAreaStyle(GeoColor.FromArgb(100, GeoColor.SimpleColors.Red), GeoColor.SimpleColors.Red, 1);  
             barrierLayer.ZoomLevelSet.ZoomLevel01.DefaultTextStyle = TextStyles.CreateSimpleTextStyle("Restricted", "Arial", 12, DrawingFontStyles.Regular, GeoColor.StandardColors.Black, GeoColor.SimpleColors.White, 2);  
             barrierLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             routingOverlay.Layers.Add("BarrierLayer", barrierLayer);  
 
             // Add Austin boundary layer  
             LayerOverlay restrictedOverlay = new LayerOverlay("AustinBoundaryOverlay");  
             map.CustomOverlays.Add(restrictedOverlay);  
 
             ShapeFileFeatureLayer restrictedLayer = new ShapeFileFeatureLayer(Server.MapPath(ConfigurationManager.AppSettings["austinCountyShapeFile"]));  
             AreaStyle extentStyle = new AreaStyle();  
             extentStyle.CustomAreaStyles.Add(new AreaStyle(new GeoSolidBrush(GeoColor.SimpleColors.Transparent)) { OutlinePen = new GeoPen(GeoColor.SimpleColors.White, 5.5f) });  
             extentStyle.CustomAreaStyles.Add(new AreaStyle(new GeoSolidBrush(GeoColor.SimpleColors.Transparent)) { OutlinePen = new GeoPen(GeoColor.SimpleColors.Red, 1.5f) { DashStyle = LineDashStyle.Dash } });  
             restrictedLayer.ZoomLevelSet.ZoomLevel01.DefaultAreaStyle = extentStyle;  
             restrictedLayer.ZoomLevelSet.ZoomLevel01.ApplyUntilZoomLevel = ApplyUntilZoomLevel.Level20;  
             restrictedOverlay.Layers.Add("RestrictedLayer", restrictedLayer);  
 
             // Add adornment overlay  
             ScaleBarAdornmentLayer scaleBarAdornmentLayer = new ScaleBarAdornmentLayer();  
             scaleBarAdornmentLayer.XOffsetInPixel = 10;  
             scaleBarAdornmentLayer.UnitFamily = UnitSystem.Metric;  
             map.AdornmentOverlay.Layers.Add("scaleBarAdornmentLayer", scaleBarAdornmentLayer);  
         }  
 
         private void AddContextMenus(Map map)  
         {  
             ContextMenu routeContextMenu = new ContextMenu("routeContextMenu", 180);  
 
             string startRouteHtml = @"<img src='../Content/Images/start.png' class='routeMenuImg'><span class='routeMenuItem'>Directions from here</span>";  
             ContextMenuItem startItem = new ContextMenuItem(startRouteHtml, "routeMenu", "routeMenuSelected", "startRouteMenu");  
             startItem.OnClientClick = "addRouteAddress";  
             routeContextMenu.MenuItems.Add(startItem);  
 
             string endRouteHtml = @"<img src='../Content/Images/end.png' class='routeMenuImg'><span class='routeMenuItem'>Directions to here</span>";  
             ContextMenuItem endItem = new ContextMenuItem(endRouteHtml, "routeMenu", "routeMenuSelected", "endRouteMenu");  
             endItem.OnClientClick = "addRouteAddress";  
             routeContextMenu.MenuItems.Add(endItem);  
 
             string stopRouteHtml = @"<img src='../Content/Images/stop.png' class='routeMenuImg'><span class='routeMenuItem'>Add a waypoint here</span>";  
             ContextMenuItem stopItem = new ContextMenuItem(stopRouteHtml, "routeMenu", "routeMenuSelected", "stopRouteMenu");  
             stopItem.OnClientClick = "addRouteAddress";  
             routeContextMenu.MenuItems.Add(stopItem);  
 
             map.ContextMenu = routeContextMenu;  
         }  
     }  
 }  
 
 

 using System;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.Routing;  
 
 namespace ThinkGeo.MapSuite.RoutingExamples  
 {  
     public class RouteDirectionModel  
     {  
         private string roadNameColumnName;  
         private string directionImageUriString;  
         private static string directionImageUriTemplate = "../Content/Images/Directions/{0}";  
 
         private Feature roadFeature;  
         private DistanceUnit lengthUnit;  
         private RouteSegment roadSegment;  
         private Feature roadSegmentFeature;  
         private GeographyUnit geographyUnit;  
 
         public RouteDirectionModel()  
         { }  
 
         public RouteDirectionModel(RouteSegment roadSegment, Feature roadFeature, string roadNameColumnName)  
 
             : this(roadSegment, roadFeature, roadNameColumnName, GeographyUnit.DecimalDegree, DistanceUnit.Meter)  
         { }  
 
         public RouteDirectionModel(RouteSegment roadSegment, Feature roadFeature, string roadNameColumnName, GeographyUnit geographyUnit, DistanceUnit lengthUnit)  
         {  
             this.roadSegment = roadSegment;  
             this.roadFeature = roadFeature;  
             this.roadNameColumnName = roadNameColumnName;  
             this.geographyUnit = geographyUnit;  
             this.lengthUnit = lengthUnit;  
         }  
 
         public DrivingDirection Direction  
         {  
             get  
             {  
                 if (roadSegment != null)  
                 {  
                     return roadSegment.DrivingDirection;  
                 }  
                 else  
                 {  
                     return DrivingDirection.Back;  
                 }  
             }  
         }  
 
         public Uri DirectionImageUri  
         {  
             get  
             {  
                 switch (Direction)  
                 {  
                     case DrivingDirection.Back:  
                         directionImageUriString = "back.png";  
                         break;  
 
                     case DrivingDirection.Forward:  
                         directionImageUriString = "Forward.png";  
                         break;  
 
                     case DrivingDirection.Invalid:  
                         directionImageUriString = "Invalid.png";  
                         break;  
 
                     case DrivingDirection.LeftForward:  
                         directionImageUriString = "LeftForward.png";  
                         break;  
 
                     case DrivingDirection.Right:  
                         directionImageUriString = "Right.png";  
                         break;  
 
                     case DrivingDirection.RightBack:  
                         directionImageUriString = "RightBack.png";  
                         break;  
 
                     case DrivingDirection.RightForward:  
                         directionImageUriString = "RightForward.png";  
                         break;  
 
                     case DrivingDirection.LeftBack:  
                         directionImageUriString = "LeftBack.png";  
                         break;  
 
                     case DrivingDirection.Left:  
                         directionImageUriString = "Left.png";  
                         break;  
                 }  
 
                 return new Uri(string.Format(directionImageUriTemplate, directionImageUriString), UriKind.RelativeOrAbsolute);  
             }  
         }  
 
         public GeographyUnit GeographyUnit  
         {  
             get { return geographyUnit; }  
             set { geographyUnit = value; }  
         }  
 
         public string Length  
         {  
             get  
             {  
                 string length = string.Empty;  
                 double value = Math.Round(((LineBaseShape)RoadFeature.GetShape()).GetLength(GeographyUnit, lengthUnit), 2);  
                 if (lengthUnit == DistanceUnit.Mile)  
                 {  
                     length = string.Format("{0} mi", value);  
                 }  
                 else  
                 {  
                     length = string.Format("{0} km", value);  
                 }  
 
                 return length;  
             }  
         }  
 
         public DistanceUnit LengthUnit  
         {  
             get { return lengthUnit; }  
             set { lengthUnit = value; }  
         }  
 
         public Feature RoadFeature  
         {  
             get { return roadFeature; }  
             set { roadFeature = value; }  
         }  
 
         public string RoadName  
         {  
             get  
             {  
                 if (!string.IsNullOrEmpty(RoadNameColumnName))  
                 {  
                     return roadFeature.ColumnValues[RoadNameColumnName];  
                 }  
                 else  
                 {  
                     return string.Empty;  
                 }  
             }  
         }  
 
         public string RoadNameColumnName  
         {  
             get { return roadNameColumnName; }  
             set { roadNameColumnName = value; }  
         }  
 
         public RouteSegment RoadSegment  
         {  
             get { return roadSegment; }  
             set { roadSegment = value; }  
         }  
 
         public Feature RoadSegmentFeature  
         {  
             get { return roadSegmentFeature; }  
             set { roadSegmentFeature = value; }  
         }  
     }  
 }  
 
 

 using System.Collections.Generic;  
 using System.Collections.ObjectModel;  
 using System.Linq;  
 using ThinkGeo.MapSuite.Core;  
 using ThinkGeo.MapSuite.Routing;  
 
 namespace ThinkGeo.MapSuite.RoutingExamples  
 {  
     public class RoutePathAndDirection  
     {  
         private readonly List<PointShape> stopPoints;  
         private readonly List<string> avoidableFeatureIds;  
 
         private PointShape endPoint;  
         private PointShape startPoint;  
         private RoutingEngine routingEngine;  
         private FeatureSource barrierFeatureSource;  
 
         public RoutePathAndDirection()  
         { }  
 
         public RoutePathAndDirection(RoutingEngine routingEngine, PointShape startPoint, PointShape endPoint)  
             : this(routingEngine, startPoint, endPoint, null)  
         {  
         }  
 
         public RoutePathAndDirection(RoutingEngine routingEngine, PointShape startPoint, PointShape endPoint, FeatureSource barrierFeatureSource)  
             : this(routingEngine, startPoint, endPoint, barrierFeatureSource, new string[] { })  
         {  
         }  
 
         public RoutePathAndDirection(RoutingEngine routingEngine, PointShape startPoint, PointShape endPoint, FeatureSource barrierFeatureSource, IEnumerable<string> avoidableFeatureIds)  
             : this(routingEngine, startPoint, endPoint, barrierFeatureSource, avoidableFeatureIds, new PointShape[] { })  
         {  
         }  
 
         public RoutePathAndDirection(RoutingEngine routingEngine, PointShape startPoint, PointShape endPoint, FeatureSource barrierFeatureSource, IEnumerable<PointShape> stopPoints)  
             : this(routingEngine, startPoint, endPoint, barrierFeatureSource, new string[] { }, stopPoints)  
         {  
         }  
 
         public RoutePathAndDirection(RoutingEngine routingEngine, PointShape startPoint, PointShape endPoint, FeatureSource barrierFeatureSource, IEnumerable<string> avoidableFeatureIds, IEnumerable<PointShape> stopPoints)  
         {  
             this.endPoint = endPoint;  
             this.startPoint = startPoint;  
             this.routingEngine = routingEngine;  
             this.barrierFeatureSource = barrierFeatureSource;  
 
             this.stopPoints = new List<PointShape>(stopPoints);  
             this.avoidableFeatureIds = new List<string>(avoidableFeatureIds);  
 
             routingEngine.RoutingAlgorithm.FindingRoute += RoutingAlgorithm_FindingRoute;  
         }  
 
         public PointShape StartPoint  
         {  
             get { return startPoint; }  
             set { startPoint = value; }  
         }  
 
         public PointShape EndPoint  
         {  
             get { return endPoint; }  
             set { endPoint = value; }  
         }  
 
         public List<PointShape> StopPoints  
         {  
             get { return stopPoints; }  
         }  
 
         public RoutingEngine RoutingEngine  
         {  
             get { return routingEngine; }  
             set { routingEngine = value; }  
         }  
 
         public List<string> AvoidableFeatureIds  
         {  
             get { return avoidableFeatureIds; }  
         }  
 
         public FeatureSource BarrierFeatureSource  
         {  
             get { return barrierFeatureSource; }  
             set { barrierFeatureSource = value; }  
         }  
 
         public RoutingResult GetRoute()  
         {  
             if (stopPoints != null && !stopPoints.Any())  
             {  
                 RoutingResult result = routingEngine.GetRoute(startPoint, endPoint);  
                 return result;  
             }  
             else  
             {  
                 Collection<PointShape> points = new Collection<PointShape>();  
                 points.Add(startPoint);  
 
                 foreach (PointShape stopPoint in stopPoints)  
                 {  
                     points.Add(stopPoint);  
                 }  
 
                 points.Add(endPoint);  
 
                 // Filter the invalid point.  
                 Collection<PointShape> availablePoint = FilterInvalidPoints(points);  
 
                 RoutingResult result = null;  
                 for (int i = 0; i < availablePoint.Count - 1; i++)  
                 {  
                     RoutingResult tempResult = routingEngine.GetRoute(availablePoint[i], availablePoint[i|+ 1]);  
                     result = CombineRoutingResult(result, tempResult);  
                 }  
 
                 return result;  
             }  
         }  
 
         private Collection<PointShape> FilterInvalidPoints(IEnumerable<PointShape> points)  
         {  
             Collection<PointShape> result = new Collection<PointShape>();  
 
             barrierFeatureSource.Open();  
             Collection<Feature> barrierFeatures = barrierFeatureSource.GetAllFeatures(ReturningColumnsType.NoColumns);  
             foreach (PointShape point in points)  
             {  
                 bool inBarrier = barrierFeatures.Any(a => a.Contains(new Feature(point)));  
                 if (!inBarrier) result.Add(point);  
             }  
 
             return result;  
         }  
 
         private RoutingResult CombineRoutingResult(RoutingResult baseResult, RoutingResult additionalResult)  
         {  
             if (baseResult == null)  
             {  
                 baseResult = new RoutingResult();  
                 baseResult.Distance = additionalResult.Distance;  
                 baseResult.Weight = additionalResult.Weight;  
                 baseResult.Route = additionalResult.Route;  
 
                 additionalResult.Features.ForEach(a => baseResult.Features.Add(a));  
                 additionalResult.OrderedStops.ForEach(a => baseResult.OrderedStops.Add(a));  
                 additionalResult.RouteSegments.ForEach(a => baseResult.RouteSegments.Add(a));  
             }  
             else  
             {  
                 baseResult.Distance += additionalResult.Distance;  
                 baseResult.Weight += additionalResult.Weight;  
 
                 Collection<Vertex> vertexes = new Collection<Vertex>();  
                 baseResult.Route.Vertices.ForEach(vertexes.Add);  
                 additionalResult.Route.Vertices.ForEach(vertexes.Add);  
 
                 baseResult.Route = new LineShape(vertexes);  
                 additionalResult.Features.ForEach(a => baseResult.Features.Add(a));  
                 additionalResult.OrderedStops.ForEach(a => baseResult.OrderedStops.Add(a));  
                 additionalResult.RouteSegments.ForEach(a => baseResult.RouteSegments.Add(a));  
             }  
 
             return baseResult;  
         }  
 
         private void RoutingAlgorithm_FindingRoute(object sender, FindingRouteRoutingAlgorithmEventArgs e)  
         {  
             Collection<string> beContainedFeatureIds = new Collection<string>();  
             barrierFeatureSource.Open();  
 
             Collection<string> startPointAdjacentIds = e.RouteSegment.StartPointAdjacentIds;  
             Collection<string> endPointAdjacentIds = e.RouteSegment.EndPointAdjacentIds;  
 
             foreach (string id in startPointAdjacentIds.Where(id => avoidableFeatureIds.Contains(id)))  
             {  
                 beContainedFeatureIds.Add(id);  
             }  
 
             foreach (string id in endPointAdjacentIds.Where(id => avoidableFeatureIds.Contains(id)))  
             {  
                 beContainedFeatureIds.Add(id);  
             }  
 
             // Remove the ones that be contained in the avoidable area  
             foreach (string id in beContainedFeatureIds)  
             {  
                 if (e.RouteSegment.StartPointAdjacentIds.Contains(id))  
                 {  
                     e.RouteSegment.StartPointAdjacentIds.Remove(id);  
                 }  
                 if (e.RouteSegment.EndPointAdjacentIds.Contains(id))  
                 {  
                     e.RouteSegment.EndPointAdjacentIds.Remove(id);  
                 }  
             }  
         }  
     }  
 }  
 

 
 namespace ThinkGeo.MapSuite.RoutingExamples  
 {  
     public enum RouteStopType  
     {  
         Start = 0,  
         Stop = 1,  
         End = 2  
     }  
 }  
 

 $(document).ready(function () {  
     initializePageElements();  
 
     // clear all the route result and addresses  
     $("#btnClearAll").bind("click", function (e) {  
         Map1.ajaxCallAction('Default', 'ClearAll', {}, function (result) {  
             var response = result.get_responseData();  
             if (response != "") {  
                 $("#divAddresses").empty().html(response);  
                 Map1.redrawLayer('RoutingOverlay');  
             }  
             $("#routeDirections").empty();  
             if (Map1.getEditOverlay() != null) {  
                 Map1.getEditOverlay().removeAllFeatures();  
             }  
             Map1.redrawLayer('RoutingOverlay');  
         });  
     });  
 
     $("#divTrackMode input[type=image]").bind("click", function () {  
         var mode = $(this).attr("command");  
         switch (mode) {  
             case "ClearAll":  
                 Map1.setDrawMode("Normal");  
                 Map1.getEditOverlay().removeAllFeatures();  
                 Map1.ajaxCallAction("default", "ClearAllBarriers", {}, function () {  
                     Map1.redrawLayer('RoutingOverlay');  
                 });  
                 $("#btnPanMap").trigger("click");  
                 break;  
             case "Undo":  
                 Map1.ajaxCallAction("default", "UndoDrawnBarrier", {}, function () {  
                     Map1.redrawLayer('RoutingOverlay');  
                 });  
                 $("#btnPanMap").trigger("click");  
                 break;  
             case "Polygon":  
                 Map1.setDrawMode("Polygon");  
                 $(this).trigger("click");  
                 break;  
             case "PanMap":  
                 Map1.setDrawMode("Normal");  
                 $("#btnPanMap").trigger("click");  
                 break;  
             default: break;  
         }  
     });  
 });  
 
 var OnMapCreated = function (map) {  
     map.events.register("mousemove", map, function (e) {  
         var mouseCoordinate = this.getLonLatFromPixel(new OpenLayers.Pixel(e.clientX, e.clientY));  
         if (mouseCoordinate) {  
             $("#spanMouseCoordinate").text("X:" + mouseCoordinate.lon.toFixed(6) + "  Y: " + mouseCoordinate.lat.toFixed(6));  
         }  
     });  
 }  
 
 function initializePageElements() {  
     var resizeElementHeight = function () {  
         var documentheight = $(window).height();  
         var contentDivH = documentheight - $("#footer").height() - $("#header").height() - 1;  
         $("#content-container").height(contentDivH + "px");  
 
         $("#leftContainer").height(contentDivH + "px");  
         $("#map-content").height(contentDivH + "px");  
         $("#toggle").css("line-height", contentDivH + "px");  
 
         if (contentDivH > 500) {  
             $("#queryResultUpdatePanel").height(contentDivH - 365 - $("#stopPanle").height() + "px");  
         } else {  
             $("#queryResultUpdatePanel").visible = false;  
         }  
 
         // refresh the map.  
         Map1.updateSize();  
     }  
 
     window.onload = resizeElementHeight();  
     $(window).resize(resizeElementHeight);  
 
     // Bind toggle button events  
     $("#toggle").bind("click", function () {  
         if ($("#leftContainer").is(':visible')) {  
             $("#collapse").attr("src", "Content/Images/expand.gif");  
             $("#map-content").css("width", "100%");  
             $("#toggle").css("left", "0%");  
             $("#leftContainer").hide();  
         }  
         else {  
             $("#leftContainer").show();  
             $("#collapse").attr("src", "Content/Images/collapse.gif");  
             $("#map-content").css("width", "80%");  
             $("#toggle").css("left", "20%");  
         }  
         resizeElementHeight();  
     });  
 
     // set the toggle style for group buttons  
     $("#divTrackMode input[type=image]").bind("click", function () {  
         var btnImgs = $("#divTrackMode input[type=image]");  
         for (var i = 0; i < btnImgs.length; i++) {  
             $(btnImgs[i]).attr("class", "imgButton");  
         }  
         $(this).attr("class", "active imgButton");  
     });  
 
     $("#warningDialog").dialog({  
         autoOpen: false,  
         modal: true,  
         buttons: {  
             Ok: function () {  
                 $(this).dialog("close");  
             }  
         }  
     });  
 }  
 
 function addRouteAddress(e) {  
     var addressText;  
     if (e.srcElement == undefined)  
         addressText = e.target;  
     else {  
         addressText = e.srcElement;  
     }  
 
     var args = { type: $(addressText).text(), x: e.worldXY.lon, y: e.worldXY.lat };  
     Map1.ajaxCallAction('Default', 'addRouteAddresses', args, function (result) {  
         var response = result.get_responseData();  
         if (response == "") {  
             $("warningDialog").dialog("open");  
         } else {  
             $("#divAddresses").empty().html(response);  
             Map1.redrawLayer('RoutingOverlay');  
         }  
     });  
 }  
 
 function removeStopItem(number) {  
     Map1.ajaxCallAction('Default', 'RemoveRouteAddresses', { x: number }, function (result) {  
         var response = result.get_responseData();  
         if (response != "") {  
             $("#divAddresses").empty().html(response);  
             Map1.redrawLayer('RoutingOverlay');  
         }  
 
         if ($("#tbAddresses tr").length < 1) {  
             $("#imgInvert").show();  
         }  
     });  
 }  
 
 function switchPoint() {  
     Map1.ajaxCallAction('Default', 'SwithStartEndPoint', {}, function (result) {  
         var startValue = $("#startPoint").val();  
         $("#startPoint").val($('#endPoint').val());  
         $('#endPoint').val(startValue);  
         // clear last route records  
         $("#routeDirections").empty();  
 
         getDirections();  
     });  
 }  
 
 function trackShapeFinished(e) {  
     var features = JSON.parse(e.features);  
     var wkts = [];  
 
     for (var i = 0; i < features.length; i++) {  
         wkts.push(features[i].wkt);  
     }  
     $("#loading").show();  
     Map1.ajaxCallAction("default", "ProcessTrackFeatures", wkts, function (result) {  
         Map1.redrawLayer('RoutingOverlay');  
         Map1.getEditOverlay().removeAllFeatures();  
         $("#loading").hide();  
     });  
 }  
 
 function resizeResultTable() {  
     var documentheight = $(window).height();  
     var contentDivH = documentheight - $("#footer").height() - $("#header").height() - 1;  
 
     if (contentDivH > 500) {  
         $("#routeDirections").height(contentDivH - 265 - $("#divAddresses").height() + "px");  
     } else {  
         $("#routeDirections").visible = false;  
     }  
 }  
 
 function getDirections() {  
     $("#loading").show();  
     Map1.ajaxCallAction('Default', 'RouteDirections', { routeMode: $('#RouteMode')[0].checked, distanceUnit: $("#DistanceUnit").val() }, function (result) {  
         $("#loading").hide();  
         $("#routeDirections").empty().html(result.get_responseData());  
         resizeResultTable();  
         Map1.redrawLayer('RoutingOverlay');  
     });  
 }  
 
 function changeDistanceUnit() {  
     getDirections();  
     Map1.getAdornmentOverlay().redraw(true);  
 }  
 
 

 @using ThinkGeo.MapSuite.Routing  
 @using ThinkGeo.MapSuite.MvcEdition  
 @using System.Collections.ObjectModel;  
 @using ThinkGeo.MapSuite.RoutingExamples;  
 @model ThinkGeo.MapSuite.MvcEdition.Map  
 @{  
     ViewBag.Title = "City Routing and Directions";  
 }  
 <div id="container">  
     <div id="header">  
         <div id="left-header">  
             <span id="header-mapsuite">Map Suite</span> <span id="header-title">City Routing and  
                 Directions</span>  
         </div>  
     </div>  
     <div id="content-container">  
         <div id="leftContainer">  
             <div id="leftContent">  
                 <h4>Right click on the map to set up a route:  
                 </h4>  
                 <div id="divAddresses">  
                     @{  
                         Html.RenderPartial("RouteStops", new RoutingLayer());  
                     }  
                 </div>  
                 <h4>Tools:</h4>  
                 <div id="divTrackMode" class="divBorder">  
                     <input type="image" id="btnPanMap" class="active" src="@Url.Content("~/Content/Images/Pan.png")" command="PanMap" title="Pan the map" />  
                     <input type="image" id="btnDrawPolygon" src="@Url.Content("~/Content/Images/draw_polygon.png")" command="Polygon" title="Draw areas to avoid traveling through"/>  
                     <input type="image" id="btnUndo" src="@Url.Content("~/Content/Images/undo.png")" command="Undo" title="Undo last area drawn"/>  
                     <input type="image" id="btnClearAllShape" src="@Url.Content("~/Content/Images/clear.png")" command="ClearAll" title="Delete all areas"/>  
                 </div>  
                 <div class="right-float">  
                     <input type="button" id="btnGetDirections" value="Get Directions" onclick="getDirections()" />  
                     <input type="button" id="btnClearAll" value="Reset Route" />  
                 </div>  
                 <div class="blueBanner">  
                     Result  
                 </div>  
                 <div id="resultOption">  
                     <div>  
                         <div class="left-float">  
                             <input type="radio" id="RouteMode" value="Shortest" name="RouteMode" checked="checked"  
                                 onclick="getDirections();" /><label for="RouteMode">Shortest</label>  
                         </div>  
                         <div class="left-float">  
                             <input type="radio" id="RouteMode1" value="Fastest" name="RouteMode" onclick="getDirections();" /><label  
                                 for="RouteMode">Fastest</label>  
                         </div>  
                         <select id="DistanceUnit" onchange="changeDistanceUnit()">  
                             <option value="Miles">Miles</option>  
                             <option value="Kilometers">Kilometers</option>  
                         </select>  
                     </div>  
                 </div>  
                 <div id="routeDirections">  
                     <table id="resultTable">  
                         <tr>  
                             <td class="header"></td>  
                             <td class="header">Road Name  
                             </td>  
                             <td class="header">Length  
                             </td>  
                         </tr>  
                     </table>  
                 </div>  
             </div>  
         </div>  
         <div id="toggle">  
             <img alt="collapse" src="@Url.Content("~/Content/Images/collapse.gif")" />  
         </div>  
         <div id="map-content">  
             @{  
                 Html.ThinkGeo().Map(Model).Render();  
             }  
         </div>  
     </div>  
     <div id="footer">  
         <span id="spanMouseCoordinate"></span>  
     </div>  
     <div id="warningDialog" title="Warning Message">  
         <p>  
             Please note that this sample map is only able to support finding the route within  
             the Austin, TX city limits, which are indicated by a dashed red line. Click inside  
             that boundary for best results.  
         </p>  
     </div>  
     <div id="loading">  
         <img id="loading-image" src="@Url.Content("Content/Images/loading.gif")" alt="Loading..." />  
     </div>  
 </div>  
 
 

 using System;  
 using System.Collections.Generic;  
 
 namespace ThinkGeo.MapSuite.RoutingExamples  
 {  
     public static class LinqExtension  
     {  
         public static void ForEach<T>(this IEnumerable<T> items, Action<T> action)  
         {  
             foreach (var item in items)  
             {  
                 if (action != null) action(item);  
             }  
         }  
     }  
 }