/// <summary> /// Initializes a new instance of the <see cref="FunctionType"/> class. /// This constructor is required for deserialization. /// </summary> public FunctionType() { FeatureTable.Seal(); DiscreteTable.Seal(); ConformanceTable.Seal(); ExportTable.Seal(); }
public static FeatureList CreateFrom(BinaryReader reader, long beginAt) { //https://www.microsoft.com/typography/otspec/chapter2.htm //FeatureList table //Type Name Description //USHORT FeatureCount Number of FeatureRecords in this table //struct FeatureRecord[FeatureCount] Array of FeatureRecords-zero-based (first feature has FeatureIndex = 0)-listed alphabetically by FeatureTag //FeatureRecord //Type Name Description //Tag FeatureTag 4-byte feature identification tag //Offset Feature Offset to Feature table-from beginning of FeatureList reader.BaseStream.Seek(beginAt, SeekOrigin.Begin); // FeatureList featureList = new FeatureList(); ushort featureCount = reader.ReadUInt16(); FeatureRecord[] featureRecords = new FeatureRecord[featureCount]; for (int i = 0; i < featureCount; ++i) { //read script record featureRecords[i] = new FeatureRecord( reader.ReadUInt32(), //feature tag reader.ReadInt16()); //offset } //read each feature table FeatureTable[] featureTables = featureList.featureTables = new FeatureTable[featureCount]; for (int i = 0; i < featureCount; ++i) { FeatureRecord frecord = featureRecords[i]; (featureTables[i] = FeatureTable.CreateFrom(reader, beginAt + frecord.offset)).FeatureTag = frecord.featureTag; } return(featureList); }
private async void Initialize() { // Create a new map centered on Aurora Colorado MyMapView.Map = new Map(BasemapType.LightGrayCanvasVector, 39.7294, -104.8319, 9); // Get the full path string geoPackagePath = GetGeoPackagePath(); try { // Open the GeoPackage GeoPackage myGeoPackage = await GeoPackage.OpenAsync(geoPackagePath); // Read the feature tables and get the first one FeatureTable geoPackageTable = myGeoPackage.GeoPackageFeatureTables.FirstOrDefault(); // Make sure a feature table was found in the package if (geoPackageTable == null) { return; } // Create a layer to show the feature table FeatureLayer newLayer = new FeatureLayer(geoPackageTable); await newLayer.LoadAsync(); // Add the feature table as a layer to the map (with default symbology) MyMapView.Map.OperationalLayers.Add(newLayer); } catch (Exception e) { await new MessageDialog(e.ToString(), "Error").ShowAsync(); } }
/// <summary> /// Get the neighborhood name for the new tree by running a spatial intersect /// </summary> internal static async Task <string> GetNeighborhoodForAddedFeature(FeatureTable neighborhoodsTable, MapPoint newTreePoint) { // if the webmap used in the app is not the tree dataset map, this method will not work if (WebmapURL != TreeDatasetWebmapUrl) { return(null); } // set the parameters for the query // we want only one neighborhood that intersects the geometry of the newly added tree var queryParams = new QueryParameters() { ReturnGeometry = false, Geometry = newTreePoint, SpatialRelationship = SpatialRelationship.Intersects, }; try { await neighborhoodsTable.LoadAsync(); var featureQueryResult = await neighborhoodsTable.QueryFeaturesAsync(queryParams); // get the first result and return it's name if (featureQueryResult.Count() > 0) { return(featureQueryResult.First().Attributes[NeighborhoodNameField].ToString()); } } catch { } // if unable to get the neighborhood, just don't populate it return(null); }
private FeatureTable GetTable(Assembly featureTestAssembly) { var libraries = LibraryProvider.GetAdapters(featureTestAssembly).ToArray(); var allVersionsGrouped = libraries.Where(l => l.PackageId != null) .Select(l => this.packageCache.GetPackage(l.PackageId)) .SelectMany(p => p.GetSupportedFrameworks()) .SelectMany(NetFxVersionHelper.Split) .Where(NetFxVersionHelper.ShouldDisplay) .GroupBy(NetFxVersionHelper.GetDisplayName) .OrderBy(g => NetFxVersionHelper.GetDisplayOrder(g.First())) .ToList(); var versionFeatures = allVersionsGrouped.Select(g => new Feature(g, g.Key)); var table = new FeatureTable(MetadataKeys.NetFxSupportTable, "Supported .NET versions", libraries, versionFeatures) { Description = "This information is based on versions included in NuGet package.", Scoring = FeatureScoring.NotScored }; foreach (var library in libraries) { this.FillNetVersionSupport(table, library, allVersionsGrouped); } return(table); }
/// <summary> /// Get all of the values in the related table to display when editing feature /// </summary> private async Task GetAvailableValues() { var queryParams = new QueryParameters() { ReturnGeometry = false, WhereClause = "1=1", }; try { // Query and load all related records var featureQueryResult = await FeatureTable.QueryFeatures(queryParams); var availableValues = new ObservableCollection <PopupManager>(); foreach (ArcGISFeature result in featureQueryResult) { if (result.LoadStatus != LoadStatus.Loaded) { await result.LoadAsync(); } availableValues.Add(new PopupManager(new Popup(result, result.FeatureTable.PopupDefinition))); } // sort the list of related records based on the first display field from the popup manager if (availableValues.Count > 0 && availableValues.First().DisplayedFields.Count() > 0) { OrderedAvailableValues = availableValues.OrderBy(PopupManager => PopupManager?.DisplayedFields?.First().Value); } } catch (Exception ex) { UserPromptMessenger.Instance.RaiseMessageValueChanged(null, ex.Message, true, ex.StackTrace); } }
private string[] GetNetFxVersions(ILibrary library, FeatureTable table) { return(table.Features.Where(f => table[library, f].State == FeatureState.Success) .Select(f => (IGrouping <string, FrameworkName>)f.Key) .Select(g => VersionUtility.GetShortFrameworkName(g.First())) .ToArray()); }
private async void Initialize() { try { // Open the custom style file. _restaurantStyle = await DictionarySymbolStyle.CreateFromFileAsync(_stylxPath); // Create a new map with a streets basemap. Map map = new Map(Basemap.CreateStreets()); // Create the restaurants layer and add it to the map. FeatureLayer restaurantLayer = new FeatureLayer(_restaurantUri); map.OperationalLayers.Add(restaurantLayer); // Load the feature table for the restaurants layer. FeatureTable restaurantTable = restaurantLayer.FeatureTable; await restaurantTable.LoadAsync(); // Set the map's initial extent to that of the restaurants. map.InitialViewpoint = new Viewpoint(restaurantLayer.FullExtent); // Set the map to the map view. MyMapView.Map = map; // Apply the custom dictionary to the restaurant feature layer. ApplyCustomDictionary(); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
private async void Initialize() { // Create the US states feature table _usStatesTable = new ServiceFeatureTable(_usStatesServiceUri); try { // Load the table await _usStatesTable.LoadAsync(); // Fill the fields combo and "group by" list with fields from the table FieldsComboBox.ItemsSource = _usStatesTable.Fields; GroupFieldsListBox.ItemsSource = _usStatesTable.Fields; // Set the (initially empty) collection of fields as the "order by" fields list data source OrderByFieldsListBox.ItemsSource = _orderByFields; // Fill the statistics type combo with values from the StatisticType enum StatTypeComboBox.ItemsSource = Enum.GetValues(typeof(StatisticType)); // Set the (initially empty) collection of statistic definitions as the statistics list box data source StatFieldsListBox.ItemsSource = _statDefinitions; } catch (Exception e) { await new MessageDialog(e.ToString(), "Error").ShowAsync(); } }
private void FillNetVersionSupport(FeatureTable table, ILibrary library, IEnumerable <IGrouping <string, FrameworkName> > allVersionsGrouped) { if (library.PackageId == null) { // this is always intentional foreach (var versionGroup in allVersionsGrouped) { var cell = table[library, versionGroup]; cell.State = FeatureState.Skipped; cell.DisplayValue = "n/a"; } return; } var package = this.packageCache.GetPackage(library.PackageId); var supported = package.GetSupportedFrameworks().ToArray(); foreach (var versionGroup in allVersionsGrouped) { var cell = table[library, versionGroup]; if (versionGroup.Any(v => VersionUtility.IsCompatible(v, supported))) { cell.State = FeatureState.Success; cell.DisplayValue = "yes"; } else { cell.State = FeatureState.Concern; cell.DisplayValue = "no"; } } }
private static void FillNetVersionSupport(FeatureTable table, IFrameworkAdapter diFramework, IPackage package, IEnumerable <IGrouping <string, FrameworkName> > allVersionsGrouped) { if (package == null) { // this is always intentional foreach (var versionGroup in allVersionsGrouped) { var cell = table[diFramework, versionGroup]; cell.State = FeatureState.Skipped; cell.DisplayText = "n/a"; } return; } var supported = package.GetSupportedFrameworks().ToArray(); foreach (var versionGroup in allVersionsGrouped) { var cell = table[diFramework, versionGroup]; if (versionGroup.Any(v => VersionUtility.IsCompatible(v, supported))) { cell.State = FeatureState.Success; cell.DisplayText = "yes"; } else { cell.State = FeatureState.Concern; cell.DisplayText = "no"; } } }
/// <summary> /// Applies edits to a table /// </summary> internal static async Task ApplyEdits(this FeatureTable featureTable) { if (featureTable is ServiceFeatureTable serviceFeatureTable) { await serviceFeatureTable.ApplyEditsAsync(); } }
private async void Initialize() { // Create the US states feature table _usStatesTable = new ServiceFeatureTable(_usStatesServiceUri); try { // Load the table await _usStatesTable.LoadAsync(); // Fill the fields combo and "group by" list with field names from the table List <string> fieldNames = _usStatesTable.Fields.Select(field => field.Name).ToList(); FieldsComboBox.ItemsSource = fieldNames; GroupFieldsListBox.ItemsSource = _usStatesTable.Fields; // Set the (initially empty) collection of fields as the "order by" fields list data source OrderByFieldsListBox.ItemsSource = _orderByFields; // Fill the statistics type combo with values from the StatisticType enum StatTypeComboBox.ItemsSource = Enum.GetValues(typeof(StatisticType)); // Set the (initially empty) collection of statistic definitions as the statistics list box data source StatFieldsListBox.ItemsSource = _statDefinitions; } catch (Exception e) { await((Page)Parent).DisplayAlert("Error", e.ToString(), "OK"); } }
/// <summary> /// Initializes a new instance of the <see cref="ProcedureType"/> class. /// This constructor is required for deserialization. /// </summary> public ProcedureType() { FeatureTable.Seal(); DiscreteTable.Seal(); ConformanceTable.Seal(); ExportTable.Seal(); }
/// <summary> /// Logic to save the edits made to a feature /// </summary> internal async Task <Feature> SaveEdits(PopupManager popupManager, FeatureTable table, ObservableCollection <DestinationRelationshipViewModel> destinationRelationships) { // feature that was edited var editedFeature = popupManager.Popup.GeoElement as ArcGISFeature; // verify that the PopupManager doesn't have any errors and prompt the user to fix errors before allowing them to save if (popupManager.HasValidationErrors()) { UserPromptMessenger.Instance.RaiseMessageValueChanged(Properties.Resources.GetString("InvalidInput_Title"), Properties.Resources.GetString("InvalidInput_Message"), true); return(null); } try { // exit the PopupManager edit session await popupManager.FinishEditingAsync(); // get relationship changes (if they exist) and relate them to the feature foreach (var destinationRelationship in destinationRelationships ?? new ObservableCollection <DestinationRelationshipViewModel>()) { if (destinationRelationship.PopupManager != null) { try { editedFeature.RelateFeature((ArcGISFeature)destinationRelationship.PopupManager.Popup.GeoElement, destinationRelationship.RelationshipInfo); } catch (Exception ex) { UserPromptMessenger.Instance.RaiseMessageValueChanged(null, ex.Message, true, ex.StackTrace); } } } // update feature await table.UpdateFeatureAsync(editedFeature); // apply edits to save the changes await editedFeature.FeatureTable.ApplyEdits(); // refresh the attributes and geometry of the feature after saving // this will returna valid ObjectID editedFeature.Refresh(); // re-select the feature (new features get unselected after the ObjectID is refreshed) if (editedFeature.Geometry != null) { var featureLayer = table.FeatureLayer; featureLayer.SelectFeature(editedFeature); } return(editedFeature); } catch (Exception ex) { UserPromptMessenger.Instance.RaiseMessageValueChanged(null, ex.Message, true, ex.StackTrace); return(null); } }
private static void CalculateTotal(FeatureTable general, IReadOnlyCollection <FeatureTable> all) { // special case var totals = general.Libraries.ToDictionary( library => library, library => all.Sum(t => t.GetScore(library)) ); var max = all.Sum(t => t.MaxScore); foreach (var total in totals) { var cell = general[total.Key, MetadataKeys.TotalFeature]; var percent = 100 * ((double)total.Value / max); cell.DisplayValue = string.Format("{0:F0}%", percent); if (percent > 70) { cell.State = FeatureState.Success; } else if (percent > 40) { cell.State = FeatureState.Concern; } else { cell.State = FeatureState.Failure; } } }
// 관리번호로 해당Feature 객체찾기 public async void SelectFct(string _FTR_CDE, string _FTR_IDN, FeatureLayer _featureLayer) { // 0.Feature 테이블 가져오기 //FeatureLayer __featureLayer = _featureLayer.Clone() as FeatureLayer; FeatureTable _featureTable = _featureLayer.FeatureTable; // Create a query parameters that will be used to Query the feature table. QueryParameters queryParams = new QueryParameters(); // Construct and assign the where clause that will be used to query the feature table. queryParams.WhereClause = " FTR_CDE = '" + _FTR_CDE + "' ORDER BY FTR_IDN DESC"; if (!FmsUtil.IsNull(_FTR_IDN)) { queryParams.WhereClause = " FTR_CDE = '" + _FTR_CDE + "' AND FTR_IDN like '%' || " + _FTR_IDN + " || '%'"; } List <Feature> features; try { // Query the feature table. FeatureQueryResult queryResult = await _featureTable.QueryFeaturesAsync(queryParams); // Cast the QueryResult to a List so the results can be interrogated. features = queryResult.ToList(); } catch (Exception e) { Messages.ShowErrMsgBox(e.Message); return; } if (features.Any()) { // Create an envelope. EnvelopeBuilder envBuilder = new EnvelopeBuilder(SpatialReferences.WebMercator); if (features.Count == 1) { //한건인 경우 선택처리 ShowFctPage(features[0]); } else { //피쳐영역 Extent 위치이동 foreach (Feature feature in features) { envBuilder.UnionOf(feature.Geometry.Extent); //복수의 피처영역 합치기 } // Zoom to the extent of the selected feature(s). await mapView.SetViewpointGeometryAsync(envBuilder.ToGeometry(), 50); } } }
private async void Initialize() { // Create a new map centered on Aurora Colorado. _myMapView.Map = new Map(BasemapType.LightGrayCanvasVector, 39.7294, -104.8319, 9); // Get the full path. string geoPackagePath = DataManager.GetDataFolder("68ec42517cdd439e81b036210483e8e7", "AuroraCO.gpkg"); // Open the GeoPackage. GeoPackage geoPackage = await GeoPackage.OpenAsync(geoPackagePath); // Read the feature tables and get the first one. FeatureTable geoPackageTable = geoPackage.GeoPackageFeatureTables.FirstOrDefault(); // Make sure a feature table was found in the package. if (geoPackageTable == null) { return; } // Create a layer to show the feature table. FeatureLayer newLayer = new FeatureLayer(geoPackageTable); await newLayer.LoadAsync(); // Add the feature table as a layer to the map (with default symbology). _myMapView.Map.OperationalLayers.Add(newLayer); }
private async void Initialize() { // Create the US states feature table _usStatesTable = new ServiceFeatureTable(_usStatesServiceUri); try { // Load the table await _usStatesTable.LoadAsync(); // Get a list of field names from the table _fieldNames = _usStatesTable.Fields.Select(field => field.Name).ToList(); // Create a dictionary of fields the user can select for grouping // The value for each is set to false initially, as nothing is selected by default _groupByFields = _fieldNames.ToDictionary(name => name, name => false); // Create a list of field options for ordering results (initially empty) _orderByFields = new List <OrderFieldOption>(); } catch (Exception e) { new AlertDialog.Builder(this).SetMessage(e.ToString()).SetTitle("Error").Show(); } }
public IEnumerable <FeatureTable> GetTables() { var testRuns = this.runner.RunAllTests(typeof(BasicTests).Assembly).ToDictionary(r => new { Test = r.Method, r.FrameworkType }); var testGroups = testRuns.Keys .Select(k => k.Test) .Distinct() .GroupBy(m => m.DeclaringType) .OrderBy(g => this.GetDisplayOrder(g.Key)) .ToArray(); foreach (var group in testGroups) { var features = group.ToDictionary(m => m, this.ConvertToFeature); var table = new FeatureTable(AttributeHelper.GetDisplayName(group.Key), Frameworks.List(), features.Values) { Description = this.GetDescription(@group.Key), Scoring = AttributeHelper.GetScoring(@group.Key) }; foreach (var test in group.OrderBy(this.GetDisplayOrder)) { foreach (var framework in Frameworks.List()) { var cell = table[framework, test]; var run = testRuns[new { Test = test, FrameworkType = framework.GetType() }]; ApplyRunResultToCell(cell, run); } } yield return(table); } }
private async void Initialize() { // Create the US states feature table. _usStatesTable = new ServiceFeatureTable(_usStatesServiceUri); try { // Load the table. await _usStatesTable.LoadAsync(); // Fill the fields combo and "group by" list with field names from the table. _fieldNames = _usStatesTable.Fields.Select(field => field.Name).ToList(); // Create a model that will provide statistic definition choices for the picker. _statsPickerModel = new StatDefinitionModel(_fieldNames.ToArray()); // Create a list of fields the user can select for grouping. // Value is initially false, since no fields are selected by default. _groupByFields = _fieldNames.ToDictionary(name => name, name => false); } catch (Exception e) { new UIAlertView("Error", e.ToString(), (IUIAlertViewDelegate)null, "OK", null).Show(); } }
/// <summary> /// Initializes a new instance of the <see cref="IndexerType"/> class. /// This constructor is required for deserialization. /// </summary> public IndexerType() { FeatureTable.Seal(); DiscreteTable.Seal(); ConformanceTable.Seal(); ExportTable.Seal(); }
public void CleanUp() { if (_fTab != null) { _fTab.ReleaseCursor(); _fTab.Dispose(); _fTab = null; } }
async private Task ProcessFeatureClass(IFeatureClass fc, IQueryFilter filter) { CleanUp(); if (fc != null) { _cursor = await fc.Search(filter); if (_cursor == null) { return; } _fTab = new FeatureTable(_cursor as IFeatureCursor, fc.Fields, fc); _fTab.RowsAddedToTable += new RowsAddedToTableEvent(fTab_RowsAddedToTable); try { await _fTab.Fill(_firstFillMaximum, _cancelTracker); } catch (System.Threading.ThreadAbortException) { _fTab.ReleaseCursor(); return; } catch (Exception ex) { MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } if (!_fTab.hasMore || (_cancelTracker != null && !_cancelTracker.Continue && !_cancelTracker.Paused)) { _fTab.ReleaseCursor(); _cursor = null; if (ThreadFinished != null) { ThreadFinished(); } } else { if (Paused != null) { Paused(); } } } else { if (ThreadFinished != null) { ThreadFinished(); } } }
private string GenerateTableId(FeatureTable table) { var result = table.DisplayName; result = Regex.Replace(result, @"\<[^>]+\>", ""); result = Regex.Replace(result, @"(?<=\W|$)\w", m => m.Value.ToUpperInvariant()); result = Regex.Replace(result, @"\W+", ""); return(result); }
/// <summary> /// Initializes a new instance of the <see cref="IdentifiedFeatureViewModel"/> class. /// </summary> public IdentifiedFeatureViewModel(Feature feature, FeatureTable featureTable, ConnectivityMode connectivityMode) { if (feature != null) { Feature = feature; PopupManager = new PopupManager(new Popup(feature, featureTable.PopupDefinition)); Fields = FieldContainer.GetFields(PopupManager); FeatureTable = featureTable; ConnectivityMode = connectivityMode; } }
/// <summary> /// Initializes a new instance of the <see cref="TupleType"/> class. /// </summary> /// <param name="entityDeclarationList">The resolved list of fields.</param> /// <param name="sharing">The type sharing.</param> /// <param name="renamedFieldTable">The list of fields to rename.</param> public TupleType(IList <IEntityDeclaration> entityDeclarationList, BaseNode.SharingType sharing, ISealableDictionary <IFeatureName, IFeatureInstance> renamedFieldTable) { EntityDeclarationList = entityDeclarationList; Sharing = sharing; FeatureTable.Merge(renamedFieldTable); FeatureTable.Seal(); DiscreteTable.Seal(); ConformanceTable.Seal(); ExportTable.Seal(); }
/// <summary> /// Calls delete on a feature /// </summary> internal static async Task DeleteFeature(this FeatureTable featureTable, Feature feature) { if (featureTable is ServiceFeatureTable serviceFeatureTable) { await serviceFeatureTable.DeleteFeatureAsync(feature); } else if (featureTable is GeodatabaseFeatureTable geodatabaseFeatureTable) { await geodatabaseFeatureTable.DeleteFeatureAsync(feature); } }
/// <summary> /// Retrieves all relationship infos for a table /// </summary> internal static IReadOnlyList <RelationshipInfo> GetRelationshipInfos(this FeatureTable featureTable) { if (featureTable is ServiceFeatureTable serviceFeatureTable) { return(serviceFeatureTable.LayerInfo.RelationshipInfos); } else if (featureTable is GeodatabaseFeatureTable geodatabaseFeatureTable) { return(geodatabaseFeatureTable.LayerInfo.RelationshipInfos); } return(null); }
/// <summary> /// Retrieves a related table based on information from the relationship info /// </summary> internal static ArcGISFeatureTable GetRelatedFeatureTable(this FeatureTable featureTable, RelationshipInfo relationshipInfo) { if (featureTable is ServiceFeatureTable serviceFeatureTable) { return(serviceFeatureTable.GetRelatedTables(relationshipInfo).FirstOrDefault()); } else if (featureTable is GeodatabaseFeatureTable geodatabaseFeatureTable) { return(geodatabaseFeatureTable.GetRelatedTables(relationshipInfo).FirstOrDefault()); } return(null); }
/// <summary> /// Calculates the data statistics for a geodatabase table. /// </summary> /// <param name="table">The geodatabase table which statistics should be gathered.</param> /// <param name="field">The field which statistics should be gathered.</param> /// <returns>The calculated data statistics.</returns> internal async Task<DataStatisticsResult> CalculateStatistics(FeatureTable table, FieldInfo field) { var result = new DataStatisticsResult { TableName = table.Name, AttributeName = field.Alias }; result.Count = table.RowCount; var filter = new QueryFilter { WhereClause = @"1=1" }; var features = await table.QueryAsync(filter); var uniqueValues = new HashSet<object>(); foreach (var feature in features) { var attributes = feature.Attributes; if (attributes.ContainsKey(field.Name)) { var value = attributes[field.Name]; if (!uniqueValues.Contains(value)) { uniqueValues.Add(value); } } } result.UniqueValueCount = uniqueValues.Count; return result; }
public static FeatureTable CreateFrom(BinaryReader reader, long beginAt) { reader.BaseStream.Seek(beginAt, SeekOrigin.Begin); // short featureParams = reader.ReadInt16();//null, should be 0 ushort lookupCount = reader.ReadUInt16(); FeatureTable featureTable = new FeatureTable(); featureTable.lookupListIndice = Utils.ReadUInt16Array(reader, lookupCount); return featureTable; }
/// <summary> /// Creates a new instance of the FeatureRow class. /// </summary> /// <param name="rb"></param> internal FeatureRow(DataRowBuilder rb) : base(rb) { _featureTable = ((FeatureTable)(Table)); }
// Summary: // Load features in a FeatureTable into a GraphicsLayer // async Task<IS3GraphicsLayer> featureTable2GraphicsLayer(FeatureTable table, int start = 0, int maxFeatures = 0, bool isShp = false) { if (table == null) return null; if (_srEMap == null) { // The spatial reference in the first table is used as the project spatial reference. // All features on other layers will be projected to the spatial reference. _srEMap = table.SpatialReference; _map.SpatialReference = table.SpatialReference; } //// We cannot use the feature layer class because it typically //// has a different SpatialReferece object (coordinate system) //// other than the tiled layer (WKID = 3857 or 102100), //// and there is no easy way to reproject feature layer //// to another coordinate system. //// We can only use the feature layer when there is no tiled layer defined, //// which is not a usual case. //FeatureLayer fLayer = new FeatureLayer(table); //fLayer.ID = table.Name; //fLayer.DisplayName = table.Name; //_map.Layers.Add(fLayer); QueryFilter qf = new QueryFilter(); qf.WhereClause = "1=1"; IEnumerable<Feature> features = await table.QueryAsync(qf); IS3GraphicCollection graphics = new IS3GraphicCollection(); int index = 0, count = 0; foreach (Feature f in features) { // jump to start position if (index++ < start) continue; // Note: // In ArcGIS Runtime SDK: User-defined coordinate system // is not allowed when using ShapefileTable.OpenAsync(). // Workaround: // (1) Do not assign user-defined CS in shape file; // (2) Assign CS dynamically here to _srEMap. // Geometry geometry = f.Geometry; if (isShp == true) { geometry = ArcGISMappingUtility.ChangeSpatailReference(geometry, _srEMap); if (geometry == null) continue; } if (_srEMap != null && isShp == false && geometry.SpatialReference != _srEMap) geometry = GeometryEngine.Project(geometry, _srEMap); // import the attributes IS3Graphic g = new IS3Graphic(geometry); foreach (KeyValuePair<string, object> item in f.Attributes.AsEnumerable()) g.Attributes.Add(item); graphics.Add(g); // Load max featuers if (maxFeatures != 0 && count++ == maxFeatures) break; } IS3GraphicsLayer gLayer = new IS3GraphicsLayer(); gLayer.DisplayName = table.Name; gLayer.GraphicsSource = graphics; gLayer.geometryType = (IS3.Core.Geometry.GeometryType)(int)table.GeometryType; return gLayer; }
/// <inheritdoc/> public DataTable GetSchemaTable() { // FeatureTable automatically has a long FID and binary Geometry. FeatureTable result = new FeatureTable(); foreach (Field field in _attributeTable.Columns) { if (Fields != null && Fields.Length > 0) { // only include desired fields in our output schema. if (!Fields.Contains(field.ColumnName)) continue; } result.Columns.Add(field.ColumnName, field.DataType); } return result; }