/// <summary> /// Method converts collection of Barriers into GPFeature collection of /// BarrierGeometryType type. /// </summary> /// <param name="barriersByTypes">Typed Barriers collection.</param> /// <param name="type">Type to convert.</param> /// <param name="attributes">Network attributes used to get barrier attributes.</param> /// <returns>GPFeature collection of specified barriers type.</returns> private static GPFeature[] _ConvertBarriers(ILookup <BarrierGeometryType, Barrier> barriersByTypes, BarrierGeometryType type, IEnumerable <NetworkAttribute> attributes) { Debug.Assert(barriersByTypes != null); // Convert Lookup Table of barriers to enumerable // collection of Barriers of specified type. var barriers = barriersByTypes[type]; GPFeature[] result = null; // Convert barriers to GPFeatures. BarriersConverter converter = new BarriersConverter(attributes); // Convert barrier by its type. if (type == BarrierGeometryType.Point) { result = converter.ConvertToPointBarriersFeatures(barriers); } else if (type == BarrierGeometryType.Polygon) { result = converter.ConvertToPolygonBarriersFeatures(barriers); } else if (type == BarrierGeometryType.Polyline) { result = converter.ConvertToLineBarriersFeatures(barriers); } else { // Not supported type. Debug.Assert(false); } return(result); }
/// <summary> /// Convert collection of Barriers to GPFeature collection of specified type. /// </summary> /// <param name="barrier">Barriers collection to convert.</param> /// param name="type">Type of barriers to convert in.</param> /// <returns>GPFeature of specified type. barrier.</returns> private GPFeature _ConvertBarrier(Barrier barrier, BarrierGeometryType type) { Debug.Assert(barrier != null); GPFeature feature = new GPFeature(); if (type == BarrierGeometryType.Point) { feature = _ConvertToPointFeature(barrier); } else if (type == BarrierGeometryType.Polygon) { feature = _ConvertToPolygonFeature(barrier); } else if (type == BarrierGeometryType.Polyline) { feature = _ConvertToPolylineFeature(barrier); } else { // Not supported. Debug.Assert(false); } return(feature); }
/// <summary> /// Determine barrier geometry type. /// </summary> /// <param name="barrier">Barrier.</param> /// <returns>Barrier geometry type.</returns> private static BarrierGeometryType _GetBarrierType(Barrier barrier) { Debug.Assert(barrier != null); BarrierGeometryType result = BarrierGeometryType.None; if (barrier.Geometry != null) { if (barrier.Geometry is Point) { result = BarrierGeometryType.Point; } else if (barrier.Geometry is Polygon) { result = BarrierGeometryType.Polygon; } else if (barrier.Geometry is Polyline) { result = BarrierGeometryType.Polyline; } else { // Not supported. Debug.Assert(false); } } return(result); }
/// <summary> /// Method gets attributes for barriers. /// </summary> /// <param name="barrier">Barrier to set attributes for.</param> /// <param name="barrierType">Barrier type.</param> /// <returns>Attributes for barrier.</returns> private AttrDictionary _GetAttributes(Barrier barrier, BarrierGeometryType barrierType) { // Fill common barriers attributes. var attr = new AttrDictionary(); attr.Add(NAAttribute.NAME, barrier.Id.ToString()); // Adjust type and time attributes for Polygon barriers. if (barrierType == BarrierGeometryType.Polygon) { if (barrier.BarrierEffect.BlockTravel == false) { attr.Add(NAAttribute.BarrierType, (int)NABarrierType.esriBarrierScaledCost); } else { attr.Add(NAAttribute.BarrierType, (int)NABarrierType.esriBarrierRestriction); } double timeFactor = _GetTimeFactor(barrier.BarrierEffect.SpeedFactorInPercent); attr.Add(NAAttribute.AttributeTimeScale, timeFactor); } // Adjust type and time attributes for Polyline barriers. else if (barrierType == BarrierGeometryType.Polyline) { attr.Add(NAAttribute.BarrierType, (int)NABarrierType.esriBarrierRestriction); } // Adjust type and time attributes for Point barriers. else if (barrierType == BarrierGeometryType.Point) { if (barrier.BarrierEffect.BlockTravel == false) { attr.Add(NAAttribute.BarrierType, (int)NABarrierType.esriBarrierAddedCost); } else { attr.Add(NAAttribute.BarrierType, (int)NABarrierType.esriBarrierRestriction); } attr.Add(NAAttribute.FullEdge, false); attr.Add(NAAttribute.CURB_APPROACH, (int)NACurbApproachType.esriNAEitherSideOfVehicle); attr.Add(NAAttribute.AttributeTimeDelay, barrier.BarrierEffect.DelayTime); } else { // Not supported type of barrier. Debug.Assert(false); } return(attr); }
/// <summary> /// Generate GPFeatureRecordSetLayer of specified barrier type. /// </summary> /// <param name="barriers">Collection of Typed Barriers to include into layer.</param> /// <param name="type">Type of barriers to convert in.</param> /// <param name="solverSR">Reference to GP spatial.</param> /// <returns>GPFeatureRecordSetLayer of barriers of specified type.</returns> private GPFeatureRecordSetLayer _GenerateLayer(IEnumerable <Barrier> barriers, BarrierGeometryType type, GPSpatialReference solverSR) { Debug.Assert(barriers != null); GPFeatureRecordSetLayer layer = null; GPFeature[] features = _ConvertBarriers(barriers, type); if (features.Length > 0) { layer = new GPFeatureRecordSetLayer(); layer.SpatialReference = solverSR; layer.Features = features; switch (type) { case BarrierGeometryType.Point: layer.GeometryType = NAGeometryType.esriGeometryPoint; break; case BarrierGeometryType.Polygon: layer.GeometryType = NAGeometryType.esriGeometryPolygon; break; case BarrierGeometryType.Polyline: layer.GeometryType = NAGeometryType.esriGeometryPolyline; break; case BarrierGeometryType.None: // Not supported type. Debug.Assert(false); break; default: Debug.Assert(false); break; } } return(layer); }
/// <summary> /// Convert collection of baTypedBarriers to collection of GPFeature of specified /// geometry type. /// </summary> /// <param name="barriers">Collection of TypedBarriers to convert.</param> /// <param name="type">Geometry type to convert in.</param> /// <returns>Collection of barrier feature with geometry type.</returns> private GPFeature[] _ConvertBarriers(IEnumerable <Barrier> barriers, BarrierGeometryType type) { Debug.Assert(barriers != null); List <GPFeature> features = new List <GPFeature>(); foreach (Barrier barrier in barriers) { if (_CanConvert(barrier, type)) { features.Add(_ConvertBarrier(barrier, type)); } else { // Type should appropriate to barrier, so it should be convertable. Debug.Assert(false); } } return(features.ToArray()); }
/// <summary> /// Determine if barrier can be converted into specified type. /// </summary> /// <param name="barrier">Barrier to convert from.</param> /// <param name="type">Type to convert.</param> /// <returns>True - if can be converted, otherwise - false.</returns> private bool _CanConvert(Barrier barrier, BarrierGeometryType type) { Debug.Assert(barrier != null); bool result = false; if (barrier.Geometry != null) { if ((type == BarrierGeometryType.Point && barrier.Geometry is Point) || (type == BarrierGeometryType.Polygon && barrier.Geometry is Polygon) || (type == BarrierGeometryType.Polyline && barrier.Geometry is Polyline)) { result = true; } else { // Not supported. Debug.Assert(false); } } return(result); }
/// <summary> /// Method converts collection of Barriers with its Geometry Types into GPFeatureRecordSetLayer of /// BarrierGeometryType type. /// </summary> /// <param name="barriersByTypes">Typed Barriers collection.</param> /// <param name="type">Type to convert.</param> /// <param name="attributes">Collection of network attribute units.</param> /// <returns>GPFeatureRecordSetLayer of specified barriers type.</returns> private static GPFeatureRecordSetLayer _ConvertBarriers(ILookup<BarrierGeometryType, Barrier> barriersByTypes, BarrierGeometryType type, IEnumerable<NetworkAttribute> attributes) { Debug.Assert(barriersByTypes != null); // Convert Lookup Table of barriers to enumerable collection of Barriers of specified type. var barriers = barriersByTypes[type]; GPFeatureRecordSetLayer result = null; if (barriers.Any()) { // Convert barriers by its types. BarriersConverter converter = new BarriersConverter(attributes); if (type == BarrierGeometryType.Point) result = converter.ConvertToPointBarriersLayer(barriers, solverSR); else if (type == BarrierGeometryType.Polygon) result = converter.ConvertToPolygonBarriersLayer(barriers, solverSR); else if (type == BarrierGeometryType.Polyline) result = converter.ConvertToLineBarriersLayer(barriers, solverSR); else // Not supported type. Debug.Assert(false); } return result; }