/// <summary> /// Gets the index of the display field for the feature's layer, if it is on the map /// </summary> /// <param name="feature">IFeature to look for</param> /// <returns>int</returns> //public int GetDisplayIndex(ESRI.ArcGIS.Geodatabase.IFeature feature) //{ // if (null == feature) // { // throw new ArgumentNullException("feature"); // } // else if (null == feature.Class) // { // throw new InvalidOperationException("feature.Class cannot be null"); // } // int result = -1; // int key = feature.Class.ObjectClassID; // if (_displayIndices.ContainsKey(key)) // { // result = _displayIndices[key]; // } // else // { // ESRI.ArcGIS.Geodatabase.IDataset dataset = feature.Class as ESRI.ArcGIS.Geodatabase.IDataset; // if (null != dataset) // { // string className = GdbUtils.ParseTableName(dataset); // ESRI.ArcGIS.Carto.IFeatureLayer ftLayer = this.FindFeatureLayer(className); // if (null != ftLayer) // { // result = feature.Fields.FindField(ftLayer.DisplayField); // } // } // _displayIndices[key] = result; // Putting it here means that we may store -1 even if the layer was undiscoverable // // even one time...we could move it into where result is assigned if we wanted // // it to recheck every time this is called // } // return result; //} /// <summary> /// Creates a new Progress Dialog in the hook, with a given ITrackCancel /// </summary> /// <param name="trackCancel">Tracks cancel</param> /// <param name="message">The message</param> /// <param name="min">Minimum progress</param> /// <param name="max">Maximum progress</param> /// <param name="step">Progress per step</param> /// <param name="desc">Description</param> /// <param name="title">Title</param> /// <returns>IProgressDialog2</returns> public ESRI.ArcGIS.Framework.IProgressDialog2 CreateProgressDialog(ESRI.ArcGIS.esriSystem.ITrackCancel trackCancel, string message, int min, int max, int step, string desc, string title) { int?hWnd = this.hWnd; if (null == hWnd) { throw new InvalidOperationException("Unable to determine hWnd of Hook"); } //ProgressBar ESRI.ArcGIS.Framework.IProgressDialogFactory progressDialogFactory = new ESRI.ArcGIS.Framework.ProgressDialogFactoryClass(); // Set the properties of the Step Progressor ESRI.ArcGIS.esriSystem.IStepProgressor stepProgressor = progressDialogFactory.Create(trackCancel, (int)hWnd); stepProgressor.MinRange = min; stepProgressor.MaxRange = max; stepProgressor.StepValue = step; stepProgressor.Message = message; // Create the ProgressDialog. This automatically displays the dialog ESRI.ArcGIS.Framework.IProgressDialog2 progressDialog = (ESRI.ArcGIS.Framework.IProgressDialog2)stepProgressor; // Explict Cast // Set the properties of the ProgressDialog progressDialog.CancelEnabled = true; progressDialog.Description = desc; progressDialog.Title = title; progressDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressGlobe; return(progressDialog); }
public override void Draw(esriDrawPhase drawPhase, IDisplay display, ESRI.ArcGIS.esriSystem.ITrackCancel trackCancel) { //var png = @"D:\\aaa\\0.png"; //var ul = new PointClass { X = -20037508.342789, Y = 20037508.342789 }; //var lr = new PointClass { X = 20037508.342789, Y = -20037508.342789 }; //ImageDrawer.Draw(display, png,ul,lr); }
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message) { try { IGPUtilities3 gpUtilities3 = new GPUtilitiesClass(); if (TrackCancel == null) { TrackCancel = new CancelTrackerClass(); } IGPParameter inputFeatureClassParameter = paramvalues.get_Element(in_osmFeaturesNumber) as IGPParameter; IGPValue inputFeatureGPValue = gpUtilities3.UnpackGPValue(inputFeatureClassParameter) as IGPValue; IFeatureClass osmFeatureClass = null; IQueryFilter queryFilter = null; gpUtilities3.DecodeFeatureLayer(inputFeatureGPValue, out osmFeatureClass, out queryFilter); ((ITable)osmFeatureClass).RemoveOSMClassExtension(); } catch (Exception ex) { message.AddError(120057, ex.Message); } }
public override void Draw(esriDrawPhase drawPhase, IDisplay display, ESRI.ArcGIS.esriSystem.ITrackCancel trackCancel) { var file = @"D:\aaa\strava_issue\2016_1350.png"; var rl = new RasterLayerClass(); rl.CreateFromFilePath(file); var props = (IRasterProps)rl.Raster; props.SpatialReference = new SpatialReferences().GetSpatialReference("urn: ogc:def: crs:EPSG: 6.18.3:3857"); IRasterGeometryProc3 rasterGeometryProc = new RasterGeometryProcClass(); var missing = Type.Missing; var layerSpatialReference = sp; rasterGeometryProc.ProjectFast(layerSpatialReference, rstResamplingTypes.RSP_NearestNeighbor, ref missing, rl.Raster); // fix 9/10/2015: with projected tiles color changes and transparency is ignored. var image = new Bitmap(file, true); // image.MakeTransparent(Color.White); //image.Save(@"D:\aaa\strava_issue\2018_1350.png"); var format = image.PixelFormat; if (format == PixelFormat.Format24bppRgb | format == PixelFormat.Format32bppArgb) { var rasterRgbRenderer = new RasterRGBRendererClass(); ((IRasterStretch2)rasterRgbRenderer).StretchType = esriRasterStretchTypesEnum.esriRasterStretch_NONE; // ((IRasterStretch3)rasterRgbRenderer).UseGamma = true; ((IRasterStretch2)rasterRgbRenderer).Background = true; ((IRasterStretch3)rasterRgbRenderer).UseGamma = true; var r = new RgbColorClass(); r.Red = 49; r.Green = 0; r.Blue = 38; ((IRasterStretch2)rasterRgbRenderer).BackgroundColor = r; //((IRasterStretch2)rasterRgbRenderer).BackgroundColor = r; rl.Renderer = rasterRgbRenderer; } // end fix 9/10/2015: with projected tiles color changes and transparency is ignored. rl.Draw(esriDrawPhase.esriDPGeography, display, null); }
public void Apply(ISchematicInMemoryDiagram inMemoryDiagram, ESRI.ArcGIS.esriSystem.ITrackCancel cancelTracker) { if (m_reducedNodeClassName == "" || inMemoryDiagram == null) { return; } // initialize the schematic rules helper ISchematicRulesHelper rulesHelper = new SchematicRulesHelperClass(); rulesHelper.InitHelper(inMemoryDiagram); rulesHelper.KeepVertices = m_keepVertices; //////////////////////// // get the feature classes processed by the rule ISchematicDiagramClass diagramClass = null; try { diagramClass = inMemoryDiagram.SchematicDiagramClass; } catch { } if (diagramClass == null) { return; } ISchematicDataset schematicDataset = null; try { schematicDataset = diagramClass.SchematicDataset; } catch { } ISchematicElementClassContainer elementclassContainer = (ISchematicElementClassContainer)schematicDataset; if (elementclassContainer == null) { return; } ISchematicElementClass elementClassReducedNode = null; elementClassReducedNode = elementclassContainer.GetSchematicElementClass(m_reducedNodeClassName); ISchematicElementClass elementClassSuperspan = null; elementClassSuperspan = elementclassContainer.GetSchematicElementClass(m_superspanLinkClassName); if (elementClassSuperspan == null || elementClassReducedNode == null) { return; } ISchematicInMemoryFeatureClassContainer featureClassContainer = (ISchematicInMemoryFeatureClassContainer)inMemoryDiagram; if (featureClassContainer == null) { return; } ISchematicInMemoryFeatureClass superspanLinkClass = featureClassContainer.GetSchematicInMemoryFeatureClass(elementClassSuperspan); // ///////////////////////// // fetch the superspan spatial reference IGeoDataset geoDataset = (IGeoDataset)superspanLinkClass; ISpatialReference spatialRef = null; if (geoDataset != null) { spatialRef = geoDataset.SpatialReference; } if (spatialRef == null) { return; } // Retrieve the schematic in memory feature nodes to reduce System.Collections.Generic.Dictionary <string, ISchematicInMemoryFeature> colSchfeatureNode = new Dictionary <string, ISchematicInMemoryFeature>(); // get all feature of parent node class IEnumSchematicInMemoryFeature enumSchematicInMemoryFeature = inMemoryDiagram.GetSchematicInMemoryFeaturesByClass(elementClassReducedNode); // retain only the nodes of degree two RetainNodesDegreeTwo(enumSchematicInMemoryFeature, colSchfeatureNode, rulesHelper); // there would be inserted a SQL query to also filter by attributes IProgressor msgProgressor = null; if (cancelTracker != null) { msgProgressor = cancelTracker.Progressor; IStepProgressor stepProgressor = (IStepProgressor)msgProgressor; if (stepProgressor != null) { stepProgressor.MinRange = 0; stepProgressor.MaxRange = colSchfeatureNode.Count; stepProgressor.StepValue = 1; stepProgressor.Position = 0; stepProgressor.Message = m_description; cancelTracker.Reset(); cancelTracker.Progressor = msgProgressor; stepProgressor.Show(); } } ISchematicInMemoryFeature schFeatureToReduce; foreach (KeyValuePair <string, ISchematicInMemoryFeature> kvp in colSchfeatureNode) { if (cancelTracker != null) { if (cancelTracker.Continue() == false) { break; } } schFeatureToReduce = colSchfeatureNode[kvp.Key]; if (schFeatureToReduce != null) { ReduceNode(rulesHelper, superspanLinkClass, spatialRef, schFeatureToReduce); } } // release memory colSchfeatureNode.Clear(); colSchfeatureNode = null; rulesHelper = null; }
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message) { IGPUtilities3 gpUtilities3 = new GPUtilitiesClass(); OSMToolHelper osmToolHelper = new OSMToolHelper(); if (TrackCancel == null) { TrackCancel = new CancelTrackerClass(); } IGPEnvironment configKeyword = OSMToolHelper.getEnvironment(envMgr, "configKeyword"); IGPString gpString = configKeyword.Value as IGPString; string storageKeyword = String.Empty; if (gpString != null) { storageKeyword = gpString.Value; } IGPParameter osmFileParameter = paramvalues.get_Element(0) as IGPParameter; IGPValue osmFileLocationString = gpUtilities3.UnpackGPValue(osmFileParameter) as IGPValue; IGPParameter loadSuperRelationParameter = paramvalues.get_Element(1) as IGPParameter; IGPBoolean loadSuperRelationGPValue = gpUtilities3.UnpackGPValue(loadSuperRelationParameter) as IGPBoolean; IGPParameter osmSourceLineFeatureClassParameter = paramvalues.get_Element(2) as IGPParameter; IGPValue osmSourceLineFeatureClassGPValue = gpUtilities3.UnpackGPValue(osmSourceLineFeatureClassParameter) as IGPValue; IGPParameter osmSourcePolygonFeatureClassParameter = paramvalues.get_Element(3) as IGPParameter; IGPValue osmSourcePolygonFeatureClassGPValue = gpUtilities3.UnpackGPValue(osmSourcePolygonFeatureClassParameter) as IGPValue; IGPParameter osmTargetLineFeatureClassParameter = paramvalues.get_Element(6) as IGPParameter; IGPValue osmTargetLineFeatureClassGPValue = gpUtilities3.UnpackGPValue(osmTargetLineFeatureClassParameter) as IGPValue; IName workspaceName = gpUtilities3.CreateParentFromCatalogPath(osmTargetLineFeatureClassGPValue.GetAsText()); IWorkspace2 lineFeatureWorkspace = workspaceName.Open() as IWorkspace2; string[] lineFCNameElements = osmTargetLineFeatureClassGPValue.GetAsText().Split(System.IO.Path.DirectorySeparatorChar); IFeatureClass osmLineFeatureClass = null; IGPParameter tagLineCollectionParameter = paramvalues.get_Element(4) as IGPParameter; IGPMultiValue tagLineCollectionGPValue = gpUtilities3.UnpackGPValue(tagLineCollectionParameter) as IGPMultiValue; List <String> lineTagstoExtract = null; if (tagLineCollectionGPValue.Count > 0) { lineTagstoExtract = new List <string>(); for (int valueIndex = 0; valueIndex < tagLineCollectionGPValue.Count; valueIndex++) { string nameOfTag = tagLineCollectionGPValue.get_Value(valueIndex).GetAsText(); lineTagstoExtract.Add(nameOfTag); } } else { lineTagstoExtract = OSMToolHelper.OSMSmallFeatureClassFields(); } // lines try { osmLineFeatureClass = osmToolHelper.CreateSmallLineFeatureClass(lineFeatureWorkspace, lineFCNameElements[lineFCNameElements.Length - 1], storageKeyword, "", "", lineTagstoExtract); } catch (Exception ex) { message.AddError(120035, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullpointfeatureclass"), ex.Message)); return; } if (osmLineFeatureClass == null) { return; } IGPParameter osmTargetPolygonFeatureClassParameter = paramvalues.get_Element(7) as IGPParameter; IGPValue osmTargetPolygonFeatureClassGPValue = gpUtilities3.UnpackGPValue(osmTargetPolygonFeatureClassParameter) as IGPValue; workspaceName = gpUtilities3.CreateParentFromCatalogPath(osmTargetPolygonFeatureClassGPValue.GetAsText()); IWorkspace2 polygonFeatureWorkspace = workspaceName.Open() as IWorkspace2; string[] polygonFCNameElements = osmTargetPolygonFeatureClassGPValue.GetAsText().Split(System.IO.Path.DirectorySeparatorChar); IFeatureClass osmPolygonFeatureClass = null; IGPParameter tagPolygonCollectionParameter = paramvalues.get_Element(5) as IGPParameter; IGPMultiValue tagPolygonCollectionGPValue = gpUtilities3.UnpackGPValue(tagPolygonCollectionParameter) as IGPMultiValue; List <String> polygonTagstoExtract = null; if (tagPolygonCollectionGPValue.Count > 0) { polygonTagstoExtract = new List <string>(); for (int valueIndex = 0; valueIndex < tagPolygonCollectionGPValue.Count; valueIndex++) { string nameOfTag = tagPolygonCollectionGPValue.get_Value(valueIndex).GetAsText(); polygonTagstoExtract.Add(nameOfTag); } } else { polygonTagstoExtract = OSMToolHelper.OSMSmallFeatureClassFields(); } // polygons try { osmPolygonFeatureClass = osmToolHelper.CreateSmallPolygonFeatureClass(polygonFeatureWorkspace, polygonFCNameElements[polygonFCNameElements.Length - 1], storageKeyword, "", "", polygonTagstoExtract); } catch (Exception ex) { message.AddError(120035, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullpointfeatureclass"), ex.Message)); return; } if (osmPolygonFeatureClass == null) { return; } ComReleaser.ReleaseCOMObject(osmPolygonFeatureClass); ComReleaser.ReleaseCOMObject(osmLineFeatureClass); string[] gdbComponents = new string[polygonFCNameElements.Length - 1]; System.Array.Copy(lineFCNameElements, gdbComponents, lineFCNameElements.Length - 1); string fileGDBLocation = String.Join(System.IO.Path.DirectorySeparatorChar.ToString(), gdbComponents); osmToolHelper.smallLoadOSMRelations(osmFileLocationString.GetAsText(), osmSourceLineFeatureClassGPValue.GetAsText(), osmSourcePolygonFeatureClassGPValue.GetAsText(), osmTargetLineFeatureClassGPValue.GetAsText(), osmTargetPolygonFeatureClassGPValue.GetAsText(), lineTagstoExtract, polygonTagstoExtract, loadSuperRelationGPValue.Value); }
private void btnSelect_Click(object sender, EventArgs e) { ESRI.ArcGIS.Framework.IProgressDialogFactory progressDialogFactory = null; ESRI.ArcGIS.esriSystem.IStepProgressor stepProgressor = null; ESRI.ArcGIS.Framework.IProgressDialog2 progressDialog = null; // Create a CancelTracker ESRI.ArcGIS.esriSystem.ITrackCancel trackCancel = null; ISpatialFilter pSpatFilt = null; IFeatureLayer pFL = null; IFeatureCursor pFCurs = null; IFeature pFeat = null; ISimpleJunctionFeature pSimpFeat = null; // Create an edit operation enabling undo/redo try { (_app.Document as IMxDocument).FocusMap.ClearSelection(); trackCancel = new ESRI.ArcGIS.Display.CancelTrackerClass(); // Set the properties of the Step Progressor System.Int32 int32_hWnd = _app.hWnd; progressDialogFactory = new ESRI.ArcGIS.Framework.ProgressDialogFactoryClass(); stepProgressor = progressDialogFactory.Create(trackCancel, int32_hWnd); stepProgressor.MinRange = 0; stepProgressor.MaxRange = lstJunctionLayers.Items.Count; stepProgressor.StepValue = 1; stepProgressor.Message = A4LGSharedFunctions.Localizer.GetString("SltByJctCountProc_1"); // Create the ProgressDialog. This automatically displays the dialog progressDialog = (ESRI.ArcGIS.Framework.IProgressDialog2)stepProgressor; // Explict Cast // Set the properties of the ProgressDialog progressDialog.CancelEnabled = true; progressDialog.Description = A4LGSharedFunctions.Localizer.GetString("SltByJctCountProc_1"); progressDialog.Title = A4LGSharedFunctions.Localizer.GetString("SltByJctCountProc_1"); progressDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressGlobe; progressDialog.ShowDialog(); for (int i = 0; i < lstJunctionLayers.Items.Count; i++) { bool boolean_Continue = trackCancel.Continue(); if (!boolean_Continue) { return; } progressDialog.Description = A4LGSharedFunctions.Localizer.GetString("SltByJctCountProc_2") + lstJunctionLayers.Items[i].ToString(); if (lstJunctionLayers.GetItemCheckState(i) == CheckState.Checked) { bool FCorLayer = true; pFL = (IFeatureLayer)Globals.FindLayer(_app, lstJunctionLayers.Items[i].ToString(), ref FCorLayer); if (pFL != null) { pSpatFilt = new SpatialFilterClass(); pSpatFilt.Geometry = _env as IGeometry; pSpatFilt.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects; pSpatFilt.GeometryField = pFL.FeatureClass.ShapeFieldName; int featCnt = pFL.FeatureClass.FeatureCount(pSpatFilt); if (featCnt > 0) { pFCurs = pFL.Search(pSpatFilt, true); pFeat = pFCurs.NextFeature(); int loopCnt = 1; while (pFeat != null) { boolean_Continue = trackCancel.Continue(); if (!boolean_Continue) { return; } stepProgressor.Message = A4LGSharedFunctions.Localizer.GetString("SltByJctCountProc_3") + loopCnt + A4LGSharedFunctions.Localizer.GetString("Of") + featCnt; if (pFeat is SimpleJunctionFeature) { pSimpFeat = (ISimpleJunctionFeature)pFeat; if (pSimpFeat.EdgeFeatureCount >= numMinEdge.Value && pSimpFeat.EdgeFeatureCount <= numMaxEdge.Value) { (_app.Document as IMxDocument).FocusMap.SelectFeature(pFL as ILayer, pFeat); } } loopCnt++; pFeat = pFCurs.NextFeature(); } } } } stepProgressor.Step(); } } catch (Exception Ex) { MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("ErrorInThe") + A4LGSharedFunctions.Localizer.GetString("SltByJctCountLbl_22") + "\r\n" + Ex.Message); } finally { if (progressDialog != null) { progressDialog.HideDialog(); } progressDialogFactory = null; stepProgressor = null; progressDialog = null; trackCancel = null; pSpatFilt = null; pFL = null; if (pFCurs != null) { System.Runtime.InteropServices.Marshal.ReleaseComObject(pFCurs); } pFCurs = null; pFeat = null; pSimpFeat = null; this.Hide(); (_app.Document as IMxDocument).ActiveView.Refresh(); MessageBox.Show((_app.Document as IMxDocument).FocusMap.SelectionCount + A4LGSharedFunctions.Localizer.GetString("SltByJctCountMess_1")); } }
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message) { try { IGPUtilities3 gpUtilities3 = new GPUtilitiesClass(); if (TrackCancel == null) { TrackCancel = new CancelTrackerClass(); } IGPParameter inputSourceLayerParameter = paramvalues.get_Element(in_sourcelayerNumber) as IGPParameter; IGPValue inputSourceLayerGPValue = gpUtilities3.UnpackGPValue(inputSourceLayerParameter) as IGPValue; IGPParameter inputTargetLayerParameter = paramvalues.get_Element(in_targetlayerNumber) as IGPParameter; IGPValue inputTargetLayerGPValue = gpUtilities3.UnpackGPValue(inputTargetLayerParameter) as IGPValue; ILayer sourceLayer = gpUtilities3.DecodeLayer(inputSourceLayerGPValue); ILayer targetLayer = gpUtilities3.DecodeLayer(inputTargetLayerGPValue); ILayerExtensions sourceLayerExtensions = sourceLayer as ILayerExtensions; if (sourceLayerExtensions == null) { message.AddWarning(resourceManager.GetString("GPTools_GPCopyLayerExtension_source_noext_support")); return; } ILayerExtensions targetLayerExtensions = targetLayer as ILayerExtensions; if (targetLayerExtensions == null) { message.AddWarning(resourceManager.GetString("GPTools_GPCopyLayerExtension_target_noext_support")); return; } // test if the feature classes already exists, // if they do and the environments settings are such that an overwrite is not allowed we need to abort at this point IGeoProcessorSettings gpSettings = (IGeoProcessorSettings)envMgr; if (gpSettings.OverwriteOutput == true) { } else { if (gpUtilities3.Exists(inputTargetLayerGPValue) == true) { message.AddError(120003, String.Format(resourceManager.GetString("GPTools_GPCopyLayerExtension_targetlayeralreadyexists"), inputTargetLayerGPValue.GetAsText())); return; } } for (int targetExtensionIndex = 0; targetExtensionIndex < targetLayerExtensions.ExtensionCount; targetExtensionIndex++) { targetLayerExtensions.RemoveExtension(targetExtensionIndex); } for (int sourceExtensionIndex = 0; sourceExtensionIndex < sourceLayerExtensions.ExtensionCount; sourceExtensionIndex++) { targetLayerExtensions.AddExtension(sourceLayerExtensions.get_Extension(sourceExtensionIndex)); } } catch (Exception ex) { message.AddError(120004, ex.Message); } }
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message) { try { IGPUtilities3 execute_Utilities = new GPUtilitiesClass(); OSMUtility osmUtility = new OSMUtility(); if (TrackCancel == null) { TrackCancel = new CancelTrackerClass(); } IGPParameter inputOSMParameter = paramvalues.get_Element(in_osmFeatureClassNumber) as IGPParameter; IGPValue inputOSMGPValue = execute_Utilities.UnpackGPValue(inputOSMParameter); IGPParameter tagFieldsParameter = paramvalues.get_Element(in_attributeSelectorNumber) as IGPParameter; IGPMultiValue tagCollectionGPValue = execute_Utilities.UnpackGPValue(tagFieldsParameter) as IGPMultiValue; if (tagCollectionGPValue == null) { message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), tagFieldsParameter.Name)); return; } IFeatureClass osmFeatureClass = null; ITable osmInputTable = null; IQueryFilter osmQueryFilter = null; try { execute_Utilities.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter); osmInputTable = osmFeatureClass as ITable; } catch { } try { if (osmInputTable == null) { execute_Utilities.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter); } } catch { } if (osmInputTable == null) { return; } // find the field that holds tag binary/xml field int osmTagCollectionFieldIndex = osmInputTable.FindField("osmTags"); // if the Field doesn't exist - wasn't found (index = -1) get out if (osmTagCollectionFieldIndex == -1) { message.AddError(120005, resourceManager.GetString("GPTools_OSMGPAttributeSelector_notagfieldfound")); return; } // set up the progress indicator IStepProgressor stepProgressor = TrackCancel as IStepProgressor; if (stepProgressor != null) { int featureCount = osmInputTable.RowCount(osmQueryFilter); stepProgressor.MinRange = 0; stepProgressor.MaxRange = featureCount; stepProgressor.Position = 0; stepProgressor.Message = resourceManager.GetString("GPTools_OSMGPCombineAttributes_progressMessage"); stepProgressor.StepValue = 1; stepProgressor.Show(); } String illegalCharacters = String.Empty; ISQLSyntax sqlSyntax = ((IDataset)osmInputTable).Workspace as ISQLSyntax; if (sqlSyntax != null) { illegalCharacters = sqlSyntax.GetInvalidCharacters(); } // establish the list of field indexes only once Dictionary <string, int> fieldIndexes = new Dictionary <string, int>(); for (int selectedGPValueIndex = 0; selectedGPValueIndex < tagCollectionGPValue.Count; selectedGPValueIndex++) { // find the field index int fieldIndex = osmInputTable.FindField(tagCollectionGPValue.get_Value(selectedGPValueIndex).GetAsText()); if (fieldIndex != -1) { string tagKeyName = osmInputTable.Fields.get_Field(fieldIndex).Name; tagKeyName = OSMToolHelper.convert2OSMKey(tagKeyName, illegalCharacters); fieldIndexes.Add(tagKeyName, fieldIndex); } } ICursor updateCursor = null; IRow osmRow = null; using (ComReleaser comReleaser = new ComReleaser()) { updateCursor = osmInputTable.Update(osmQueryFilter, false); comReleaser.ManageLifetime(updateCursor); osmRow = updateCursor.NextRow(); int progressIndex = 0; while (osmRow != null) { // get the current tag collection from the row ESRI.ArcGIS.OSM.OSMClassExtension.tag[] osmTags = osmUtility.retrieveOSMTags(osmRow, osmTagCollectionFieldIndex, ((IDataset)osmInputTable).Workspace); Dictionary <string, string> tagsDictionary = new Dictionary <string, string>(); for (int tagIndex = 0; tagIndex < osmTags.Length; tagIndex++) { tagsDictionary.Add(osmTags[tagIndex].k, osmTags[tagIndex].v); } // look if the tag needs to be updated or added bool tagsUpdated = false; foreach (var fieldItem in fieldIndexes) { object fldValue = osmRow.get_Value(fieldItem.Value); if (fldValue != System.DBNull.Value) { if (tagsDictionary.ContainsKey(fieldItem.Key)) { if (!tagsDictionary[fieldItem.Key].Equals(fldValue)) { tagsDictionary[fieldItem.Key] = Convert.ToString(fldValue); tagsUpdated = true; } } else { tagsDictionary.Add(fieldItem.Key, Convert.ToString(fldValue)); tagsUpdated = true; } } else { if (tagsDictionary.ContainsKey(fieldItem.Key)) { tagsDictionary.Remove(fieldItem.Key); tagsUpdated = true; } } } if (tagsUpdated) { List <ESRI.ArcGIS.OSM.OSMClassExtension.tag> updatedTags = new List <ESRI.ArcGIS.OSM.OSMClassExtension.tag>(); foreach (var tagItem in tagsDictionary) { ESRI.ArcGIS.OSM.OSMClassExtension.tag newTag = new ESRI.ArcGIS.OSM.OSMClassExtension.tag(); newTag.k = tagItem.Key; newTag.v = tagItem.Value; updatedTags.Add(newTag); } // insert the tags back into the collection field if (updatedTags.Count != 0) { osmUtility.insertOSMTags(osmTagCollectionFieldIndex, osmRow, updatedTags.ToArray(), ((IDataset)osmInputTable).Workspace); updateCursor.UpdateRow(osmRow); } } progressIndex++; if (stepProgressor != null) { stepProgressor.Position = progressIndex; } if (osmRow != null) { Marshal.ReleaseComObject(osmRow); } osmRow = updateCursor.NextRow(); } if (stepProgressor != null) { stepProgressor.Hide(); } } } catch (Exception ex) { message.AddError(120007, ex.Message); } }
void IFeatureRenderer.Draw(ESRI.ArcGIS.Geodatabase.IFeatureCursor Cursor, ESRI.ArcGIS.esriSystem.esriDrawPhase DrawPhase, IDisplay Display, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel) { // do not draw features if no display if (Display == null) { return; } else { IFeature pFeat = null; intBrksCount = arrClassBrks.Length - 1; ILineFillSymbol pLineFillSym = new LineFillSymbolClass(); pFeat = Cursor.NextFeature(); dblInstantSep = (dblFromSep - dblToSep) / Convert.ToDouble(intBrksCount - 1); int i = 0; //Start Loop while (pFeat != null) { IFeatureDraw pFeatDraw = (IFeatureDraw)pFeat; pLineFillSym = new LineFillSymbolClass(); pLineFillSym.Angle = dblLineAngle; pLineFillSym.Color = pLineRgb; pLineFillSym.LineSymbol.Width = dblLineWidth; for (int j = 0; j < intBrksCount; j++) { if (arrValue[i] >= arrClassBrks[j] && arrValue[i] <= arrClassBrks[j + 1]) { pLineFillSym.Separation = dblToSep + (dblInstantSep * Convert.ToDouble(j)); } } Display.SetSymbol((ISymbol)pLineFillSym); pFeatDraw.Draw(esriDrawPhase.esriDPGeography, Display, (ISymbol)pLineFillSym, true, null, esriDrawStyle.esriDSNormal); i++; pFeat = Cursor.NextFeature(); } } }
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message) { try { IGPUtilities3 execute_Utilities = new GPUtilitiesClass(); if (TrackCancel == null) { TrackCancel = new CancelTrackerClass(); } IGPParameter inputFeatureDatasetParameter = paramvalues.get_Element(in_featureDatasetParameterNumber) as IGPParameter; IGPValue inputFeatureDatasetGPValue = execute_Utilities.UnpackGPValue(inputFeatureDatasetParameter); IGPValue outputOSMFileGPValue = execute_Utilities.UnpackGPValue(paramvalues.get_Element(out_osmFileLocationParameterNumber)); // get the name of the feature dataset int fdDemlimiterPosition = inputFeatureDatasetGPValue.GetAsText().LastIndexOf("\\"); string nameOfFeatureDataset = inputFeatureDatasetGPValue.GetAsText().Substring(fdDemlimiterPosition + 1); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; System.Xml.XmlWriter xmlWriter = null; try { xmlWriter = XmlWriter.Create(outputOSMFileGPValue.GetAsText(), settings); } catch (Exception ex) { message.AddError(120021, ex.Message); return; } xmlWriter.WriteStartDocument(); xmlWriter.WriteStartElement("osm"); // start the osm root node xmlWriter.WriteAttributeString("version", "0.6"); // add the version attribute xmlWriter.WriteAttributeString("generator", "ArcGIS Editor for OpenStreetMap"); // add the generator attribute // write all the nodes // use a feature search cursor to loop through all the known points and write them out as osm node IFeatureClassContainer osmFeatureClasses = execute_Utilities.OpenDataset(inputFeatureDatasetGPValue) as IFeatureClassContainer; if (osmFeatureClasses == null) { message.AddError(120022, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), inputFeatureDatasetParameter.Name)); return; } IFeatureClass osmPointFeatureClass = osmFeatureClasses.get_ClassByName(nameOfFeatureDataset + "_osm_pt"); if (osmPointFeatureClass == null) { message.AddError(120023, string.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_no_pointfeatureclass"), nameOfFeatureDataset + "_osm_pt")); return; } // check the extension of the point feature class to determine its version int internalOSMExtensionVersion = osmPointFeatureClass.OSMExtensionVersion(); IFeatureCursor searchCursor = null; System.Xml.Serialization.XmlSerializerNamespaces xmlnsEmpty = new System.Xml.Serialization.XmlSerializerNamespaces(); xmlnsEmpty.Add("", ""); message.AddMessage(resourceManager.GetString("GPTools_OSMGPExport2OSM_exporting_pts_msg")); int pointCounter = 0; string nodesExportedMessage = String.Empty; // collect the indices for the point feature class once int pointOSMIDFieldIndex = osmPointFeatureClass.Fields.FindField("OSMID"); int pointChangesetFieldIndex = osmPointFeatureClass.Fields.FindField("osmchangeset"); int pointVersionFieldIndex = osmPointFeatureClass.Fields.FindField("osmversion"); int pointUIDFieldIndex = osmPointFeatureClass.Fields.FindField("osmuid"); int pointUserFieldIndex = osmPointFeatureClass.Fields.FindField("osmuser"); int pointTimeStampFieldIndex = osmPointFeatureClass.Fields.FindField("osmtimestamp"); int pointVisibleFieldIndex = osmPointFeatureClass.Fields.FindField("osmvisible"); int pointTagsFieldIndex = osmPointFeatureClass.Fields.FindField("osmTags"); using (ComReleaser comReleaser = new ComReleaser()) { searchCursor = osmPointFeatureClass.Search(null, false); comReleaser.ManageLifetime(searchCursor); System.Xml.Serialization.XmlSerializer pointSerializer = new System.Xml.Serialization.XmlSerializer(typeof(node)); IFeature currentFeature = searchCursor.NextFeature(); IWorkspace pointWorkspace = ((IDataset)osmPointFeatureClass).Workspace; while (currentFeature != null) { if (TrackCancel.Continue() == true) { // convert the found point feature into a osm node representation to store into the OSM XML file node osmNode = ConvertPointFeatureToOSMNode(currentFeature, pointWorkspace, pointTagsFieldIndex, pointOSMIDFieldIndex, pointChangesetFieldIndex, pointVersionFieldIndex, pointUIDFieldIndex, pointUserFieldIndex, pointTimeStampFieldIndex, pointVisibleFieldIndex, internalOSMExtensionVersion); pointSerializer.Serialize(xmlWriter, osmNode, xmlnsEmpty); // increase the point counter to later status report pointCounter++; currentFeature = searchCursor.NextFeature(); } else { // properly close the document xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document // report the number of elements loader so far nodesExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_pts_exported_msg"), pointCounter); message.AddMessage(nodesExportedMessage); return; } } } nodesExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_pts_exported_msg"), pointCounter); message.AddMessage(nodesExportedMessage); // next loop through the line and polygon feature classes to export those features as ways // in case we encounter a multi-part geometry, store it in a relation collection that will be serialized when exporting the relations table IFeatureClass osmLineFeatureClass = osmFeatureClasses.get_ClassByName(nameOfFeatureDataset + "_osm_ln"); if (osmLineFeatureClass == null) { message.AddError(120023, string.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_no_linefeatureclass"), nameOfFeatureDataset + "_osm_ln")); return; } message.AddMessage(resourceManager.GetString("GPTools_OSMGPExport2OSM_exporting_ways_msg")); // as we are looping through the line and polygon feature classes let's collect the multi-part features separately // as they are considered relations in the OSM world List<relation> multiPartElements = new List<relation>(); System.Xml.Serialization.XmlSerializer waySerializer = new System.Xml.Serialization.XmlSerializer(typeof(way)); int lineCounter = 0; int relationCounter = 0; string waysExportedMessage = String.Empty; using (ComReleaser comReleaser = new ComReleaser()) { searchCursor = osmLineFeatureClass.Search(null, false); comReleaser.ManageLifetime(searchCursor); IFeature currentFeature = searchCursor.NextFeature(); // collect the indices for the point feature class once int lineOSMIDFieldIndex = osmLineFeatureClass.Fields.FindField("OSMID"); int lineChangesetFieldIndex = osmLineFeatureClass.Fields.FindField("osmchangeset"); int lineVersionFieldIndex = osmLineFeatureClass.Fields.FindField("osmversion"); int lineUIDFieldIndex = osmLineFeatureClass.Fields.FindField("osmuid"); int lineUserFieldIndex = osmLineFeatureClass.Fields.FindField("osmuser"); int lineTimeStampFieldIndex = osmLineFeatureClass.Fields.FindField("osmtimestamp"); int lineVisibleFieldIndex = osmLineFeatureClass.Fields.FindField("osmvisible"); int lineTagsFieldIndex = osmLineFeatureClass.Fields.FindField("osmTags"); int lineMembersFieldIndex = osmLineFeatureClass.Fields.FindField("osmMembers"); IWorkspace lineWorkspace = ((IDataset)osmLineFeatureClass).Workspace; while (currentFeature != null) { if (TrackCancel.Continue() == false) { // properly close the document xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document // report the number of elements loaded so far waysExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_ways_exported_msg"), lineCounter); message.AddMessage(waysExportedMessage); return; } //test if the feature geometry has multiple parts IGeometryCollection geometryCollection = currentFeature.Shape as IGeometryCollection; if (geometryCollection != null) { if (geometryCollection.GeometryCount == 1) { // convert the found polyline feature into a osm way representation to store into the OSM XML file way osmWay = ConvertFeatureToOSMWay(currentFeature, lineWorkspace, osmPointFeatureClass, pointOSMIDFieldIndex, lineTagsFieldIndex, lineOSMIDFieldIndex, lineChangesetFieldIndex, lineVersionFieldIndex, lineUIDFieldIndex, lineUserFieldIndex, lineTimeStampFieldIndex, lineVisibleFieldIndex, internalOSMExtensionVersion); waySerializer.Serialize(xmlWriter, osmWay, xmlnsEmpty); // increase the line counter for later status report lineCounter++; } else { relation osmRelation = ConvertRowToOSMRelation((IRow)currentFeature, lineWorkspace, lineTagsFieldIndex, lineOSMIDFieldIndex, lineChangesetFieldIndex, lineVersionFieldIndex, lineUIDFieldIndex, lineUserFieldIndex, lineTimeStampFieldIndex, lineVisibleFieldIndex, lineMembersFieldIndex, internalOSMExtensionVersion); multiPartElements.Add(osmRelation); // increase the line counter for later status report relationCounter++; } } currentFeature = searchCursor.NextFeature(); } } IFeatureClass osmPolygonFeatureClass = osmFeatureClasses.get_ClassByName(nameOfFeatureDataset + "_osm_ply"); IFeatureWorkspace commonWorkspace = ((IDataset)osmPolygonFeatureClass).Workspace as IFeatureWorkspace; if (osmPolygonFeatureClass == null) { message.AddError(120024, string.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_no_polygonfeatureclass"), nameOfFeatureDataset + "_osm_ply")); return; } using (ComReleaser comReleaser = new ComReleaser()) { searchCursor = osmPolygonFeatureClass.Search(null, false); comReleaser.ManageLifetime(searchCursor); IFeature currentFeature = searchCursor.NextFeature(); // collect the indices for the point feature class once int polygonOSMIDFieldIndex = osmPolygonFeatureClass.Fields.FindField("OSMID"); int polygonChangesetFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmchangeset"); int polygonVersionFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmversion"); int polygonUIDFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmuid"); int polygonUserFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmuser"); int polygonTimeStampFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmtimestamp"); int polygonVisibleFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmvisible"); int polygonTagsFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmTags"); int polygonMembersFieldIndex = osmPolygonFeatureClass.Fields.FindField("osmMembers"); IWorkspace polygonWorkspace = ((IDataset)osmPolygonFeatureClass).Workspace; while (currentFeature != null) { if (TrackCancel.Continue() == false) { // properly close the document xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document // report the number of elements loaded so far waysExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_ways_exported_msg"), lineCounter); message.AddMessage(waysExportedMessage); message.AddAbort(resourceManager.GetString("GPTools_toolabort")); return; } //test if the feature geometry has multiple parts IGeometryCollection geometryCollection = currentFeature.Shape as IGeometryCollection; if (geometryCollection != null) { if (geometryCollection.GeometryCount == 1) { // convert the found polyline feature into a osm way representation to store into the OSM XML file way osmWay = ConvertFeatureToOSMWay(currentFeature, polygonWorkspace, osmPointFeatureClass, pointOSMIDFieldIndex, polygonTagsFieldIndex, polygonOSMIDFieldIndex, polygonChangesetFieldIndex, polygonVersionFieldIndex, polygonUIDFieldIndex, polygonUserFieldIndex, polygonTimeStampFieldIndex, polygonVisibleFieldIndex, internalOSMExtensionVersion); waySerializer.Serialize(xmlWriter, osmWay, xmlnsEmpty); // increase the line counter for later status report lineCounter++; } else { relation osmRelation = ConvertRowToOSMRelation((IRow)currentFeature, polygonWorkspace, polygonTagsFieldIndex, polygonOSMIDFieldIndex, polygonChangesetFieldIndex, polygonVersionFieldIndex, polygonUIDFieldIndex, polygonUserFieldIndex, polygonTimeStampFieldIndex, polygonVisibleFieldIndex, polygonMembersFieldIndex, internalOSMExtensionVersion); multiPartElements.Add(osmRelation); // increase the line counter for later status report relationCounter++; } } currentFeature = searchCursor.NextFeature(); } } waysExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_ways_exported_msg"), lineCounter); message.AddMessage(waysExportedMessage); // now let's go through the relation table message.AddMessage(resourceManager.GetString("GPTools_OSMGPExport2OSM_exporting_relations_msg")); ITable relationTable = commonWorkspace.OpenTable(nameOfFeatureDataset + "_osm_relation"); if (relationTable == null) { message.AddError(120025, String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_no_relationTable"), nameOfFeatureDataset + "_osm_relation")); return; } System.Xml.Serialization.XmlSerializer relationSerializer = new System.Xml.Serialization.XmlSerializer(typeof(relation)); string relationsExportedMessage = String.Empty; using (ComReleaser comReleaser = new ComReleaser()) { ICursor rowCursor = relationTable.Search(null, false); comReleaser.ManageLifetime(rowCursor); IRow currentRow = rowCursor.NextRow(); // collect the indices for the relation table once int relationOSMIDFieldIndex = relationTable.Fields.FindField("OSMID"); int relationChangesetFieldIndex = relationTable.Fields.FindField("osmchangeset"); int relationVersionFieldIndex = relationTable.Fields.FindField("osmversion"); int relationUIDFieldIndex = relationTable.Fields.FindField("osmuid"); int relationUserFieldIndex = relationTable.Fields.FindField("osmuser"); int relationTimeStampFieldIndex = relationTable.Fields.FindField("osmtimestamp"); int relationVisibleFieldIndex = relationTable.Fields.FindField("osmvisible"); int relationTagsFieldIndex = relationTable.Fields.FindField("osmTags"); int relationMembersFieldIndex = relationTable.Fields.FindField("osmMembers"); IWorkspace polygonWorkspace = ((IDataset)osmPolygonFeatureClass).Workspace; while (currentRow != null) { if (TrackCancel.Continue() == false) { // properly close the document xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document // report the number of elements loaded so far relationsExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_relations_exported_msg"), relationCounter); message.AddMessage(relationsExportedMessage); message.AddAbort(resourceManager.GetString("GPTools_toolabort")); return; } relation osmRelation = ConvertRowToOSMRelation(currentRow, (IWorkspace)commonWorkspace, relationTagsFieldIndex, relationOSMIDFieldIndex, relationChangesetFieldIndex, relationVersionFieldIndex, relationUIDFieldIndex, relationUserFieldIndex, relationTimeStampFieldIndex, relationVisibleFieldIndex, relationMembersFieldIndex, internalOSMExtensionVersion); relationSerializer.Serialize(xmlWriter, osmRelation, xmlnsEmpty); // increase the line counter for later status report relationCounter++; currentRow = rowCursor.NextRow(); } } // lastly let's serialize the collected multipart-geometries back into relation elements foreach (relation currentRelation in multiPartElements) { if (TrackCancel.Continue() == false) { // properly close the document xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document // report the number of elements loaded so far relationsExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_relations_exported_msg"), relationCounter); message.AddMessage(relationsExportedMessage); return; } relationSerializer.Serialize(xmlWriter, currentRelation, xmlnsEmpty); relationCounter++; } relationsExportedMessage = String.Format(resourceManager.GetString("GPTools_OSMGPExport2OSM_relations_exported_msg"), relationCounter); message.AddMessage(relationsExportedMessage); xmlWriter.WriteEndElement(); // closing the osm root element xmlWriter.WriteEndDocument(); // finishing the document xmlWriter.Close(); // closing the document } catch (Exception ex) { message.AddError(11111, ex.StackTrace); message.AddError(120026, ex.Message); } }
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message) { try { IGPUtilities3 gpUtilities3 = new GPUtilitiesClass() as IGPUtilities3; if (TrackCancel == null) { TrackCancel = new CancelTrackerClass(); } // decode in the input layers IGPParameter in_SourceFeatureClassParameter = paramvalues.get_Element(in_sourceFeatureClassNumber) as IGPParameter; IGPValue in_SourceFeatureGPValue = gpUtilities3.UnpackGPValue(in_SourceFeatureClassParameter) as IGPValue; IFeatureClass sourceFeatureClass = null; IQueryFilter queryFilter = null; gpUtilities3.DecodeFeatureLayer((IGPValue)in_SourceFeatureGPValue, out sourceFeatureClass, out queryFilter); if (sourceFeatureClass == null) { message.AddError(120027, resourceManager.GetString("GPTools_OSMGPFeatureComparison_source_nullpointer")); return; } IGPParameter in_NumberOfIntersectionsFieldParameter = paramvalues.get_Element(in_sourceIntersectionFieldNumber) as IGPParameter; IGPValue in_NumberOfIntersectionsFieldGPValue = gpUtilities3.UnpackGPValue(in_NumberOfIntersectionsFieldParameter) as IGPValue; IGPParameter in_SourceRefIDFieldParameter = paramvalues.get_Element(in_sourceRefIDsFieldNumber) as IGPParameter; IGPValue in_SourceRefIDFieldGPValue = gpUtilities3.UnpackGPValue(in_SourceRefIDFieldParameter) as IGPValue; IGPParameter in_MatchFeatureClassParameter = paramvalues.get_Element(in_MatchFeatureClassNumber) as IGPParameter; IGPValue in_MatchFeatureGPValue = gpUtilities3.UnpackGPValue(in_MatchFeatureClassParameter) as IGPValue; IFeatureClass matchFeatureClass = null; IQueryFilter matchQueryFilter = null; gpUtilities3.DecodeFeatureLayer((IGPValue)in_MatchFeatureGPValue, out matchFeatureClass, out matchQueryFilter); if (matchFeatureClass == null) { message.AddError(120028, resourceManager.GetString("GPTools_OSMGPFeatureComparison_match_nullpointer")); return; } if (queryFilter != null) { if (((IGeoDataset)matchFeatureClass).SpatialReference != null) { queryFilter.set_OutputSpatialReference(sourceFeatureClass.ShapeFieldName, ((IGeoDataset)matchFeatureClass).SpatialReference); } } IWorkspace sourceWorkspace = ((IDataset)sourceFeatureClass).Workspace; IWorkspaceEdit sourceWorkspaceEdit = sourceWorkspace as IWorkspaceEdit; if (sourceWorkspace.Type == esriWorkspaceType.esriRemoteDatabaseWorkspace) { sourceWorkspaceEdit = sourceWorkspace as IWorkspaceEdit; sourceWorkspaceEdit.StartEditing(false); sourceWorkspaceEdit.StartEditOperation(); } // get an overall feature count as that determines the progress indicator int featureCount = ((ITable)sourceFeatureClass).RowCount(queryFilter); // set up the progress indicator IStepProgressor stepProgressor = TrackCancel as IStepProgressor; if (stepProgressor != null) { stepProgressor.MinRange = 0; stepProgressor.MaxRange = featureCount; stepProgressor.Position = 0; stepProgressor.Message = resourceManager.GetString("GPTools_OSMGPFeatureComparison_progressMessage"); stepProgressor.StepValue = 1; stepProgressor.Show(); } int numberOfIntersectionsFieldIndex = sourceFeatureClass.FindField(in_NumberOfIntersectionsFieldGPValue.GetAsText()); int sourceRefIDFieldIndex = sourceFeatureClass.FindField(in_SourceRefIDFieldGPValue.GetAsText()); ISpatialFilter matchFCSpatialFilter = new SpatialFilter(); matchFCSpatialFilter.GeometryField = matchFeatureClass.ShapeFieldName; matchFCSpatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects; matchFCSpatialFilter.WhereClause = matchQueryFilter.WhereClause; using (ComReleaser comReleaser = new ComReleaser()) { IFeatureCursor sourceFeatureCursor = sourceFeatureClass.Search(queryFilter, false); comReleaser.ManageLifetime(sourceFeatureCursor); IFeature sourceFeature = null; while ((sourceFeature = sourceFeatureCursor.NextFeature()) != null) { int numberOfIntersections = 0; string intersectedFeatures = String.Empty; IPolyline sourceLine = sourceFeature.Shape as IPolyline; matchFCSpatialFilter.Geometry = sourceLine; using (ComReleaser innerReleaser = new ComReleaser()) { IFeatureCursor matchFeatureCursor = matchFeatureClass.Search(matchFCSpatialFilter, false); innerReleaser.ManageLifetime(matchFeatureCursor); IFeature matchFeature = null; while ((matchFeature = matchFeatureCursor.NextFeature()) != null) { IPointCollection intersectionPointCollection = null; try { ITopologicalOperator topoOperator = sourceLine as ITopologicalOperator; if (topoOperator.IsSimple == false) { ((ITopologicalOperator2)topoOperator).IsKnownSimple_2 = false; topoOperator.Simplify(); } IPolyline matchPolyline = matchFeature.Shape as IPolyline; if (queryFilter != null) { matchPolyline.Project(sourceLine.SpatialReference); } if (((ITopologicalOperator)matchPolyline).IsSimple == false) { ((ITopologicalOperator2)matchPolyline).IsKnownSimple_2 = false; ((ITopologicalOperator)matchPolyline).Simplify(); } intersectionPointCollection = topoOperator.Intersect(matchPolyline, esriGeometryDimension.esriGeometry0Dimension) as IPointCollection; } catch (Exception ex) { message.AddWarning(ex.Message); continue; } if (intersectionPointCollection != null && intersectionPointCollection.PointCount > 0) { numberOfIntersections = numberOfIntersections + intersectionPointCollection.PointCount; if (String.IsNullOrEmpty(intersectedFeatures)) { intersectedFeatures = matchFeature.OID.ToString(); } else { intersectedFeatures = intersectedFeatures + "," + matchFeature.OID.ToString(); } } } if (numberOfIntersectionsFieldIndex > -1) { sourceFeature.set_Value(numberOfIntersectionsFieldIndex, numberOfIntersections); } if (sourceRefIDFieldIndex > -1) { if (intersectedFeatures.Length > sourceFeatureClass.Fields.get_Field(sourceRefIDFieldIndex).Length) { sourceFeature.set_Value(sourceRefIDFieldIndex, intersectedFeatures.Substring(0, sourceFeatureClass.Fields.get_Field(sourceRefIDFieldIndex).Length)); } else { sourceFeature.set_Value(sourceRefIDFieldIndex, intersectedFeatures); } } } try { sourceFeature.Store(); } catch (Exception ex) { message.AddWarning(ex.Message); } if (stepProgressor != null) { // update the progress UI stepProgressor.Step(); } // check for user cancellation if (TrackCancel.Continue() == false) { return; } } } if (sourceWorkspaceEdit != null) { sourceWorkspaceEdit.StopEditOperation(); sourceWorkspaceEdit.StopEditing(true); } if (stepProgressor != null) { stepProgressor.Hide(); } } catch (Exception ex) { message.AddAbort(ex.Message); } }
public void Apply(ISchematicInMemoryDiagram inMemoryDiagram, ESRI.ArcGIS.esriSystem.ITrackCancel cancelTracker) { ISchematicRulesHelper rulesHelper = new SchematicRulesHelperClass(); System.Collections.Generic.Dictionary <string, ISchematicInMemoryFeature> colSchfeatureNode = new Dictionary <string, ISchematicInMemoryFeature>(); rulesHelper.InitHelper(inMemoryDiagram); rulesHelper.KeepVertices = true; ISchematicDiagramClass diagramClass = null; ISchematicElementClass elementClass; ISchematicElementClass elementClassParentNode = null; IEnumSchematicElementClass enumSchEltCls; try { diagramClass = inMemoryDiagram.SchematicDiagramClass; } catch { } if (diagramClass == null) { return; } enumSchEltCls = diagramClass.AssociatedSchematicElementClasses; if (enumSchEltCls.Count == 0) { return; } enumSchEltCls.Reset(); elementClass = enumSchEltCls.Next(); while (elementClass != null) { if (elementClass.Name == m_parentNodeClassName) { elementClassParentNode = elementClass; m_parentNodeClass = GetSchematicInMemoryFeatureClass(inMemoryDiagram, elementClass); } if (elementClass.Name == m_targetNodeClassName) { m_targetNodeClass = GetSchematicInMemoryFeatureClass(inMemoryDiagram, elementClass); } if (elementClass.Name == m_targetLinkClassName) { m_targetLinkClass = GetSchematicInMemoryFeatureClass(inMemoryDiagram, elementClass); } elementClass = enumSchEltCls.Next(); } if (m_parentNodeClass == null || m_targetNodeClass == null || m_targetLinkClass == null) { return; } IEnumSchematicInMemoryFeature enumSchematicInMemoryFeature; // list nodes degree two // get all feature of parent node class enumSchematicInMemoryFeature = inMemoryDiagram.GetSchematicInMemoryFeaturesByClass(elementClassParentNode); enumSchematicInMemoryFeature.Reset(); // add the node into collection if it contains only 2 links displayed. AddNodesDegreeTwo(enumSchematicInMemoryFeature, colSchfeatureNode, rulesHelper); ISchematicInMemoryFeature schFeatureParent; foreach (KeyValuePair <string, ISchematicInMemoryFeature> kvp in colSchfeatureNode) { schFeatureParent = colSchfeatureNode[kvp.Key]; if (schFeatureParent == null) { continue; } // get 2 links connected of eache feature node IEnumSchematicInMemoryFeature enumLinks = rulesHelper.GetDisplayedIncidentLinks((ISchematicInMemoryFeatureNode)schFeatureParent, esriSchematicEndPointType.esriSchematicOriginOrExtremityNode); // enumLinks surely not null and it contain 2 links displayed double angle1, angle2, angleBisector; bool first = true; angle1 = angle2 = angleBisector = 0; IPoint pointParent = null; ISchematicInMemoryFeatureNodeGeometry geoParent; geoParent = (ISchematicInMemoryFeatureNodeGeometry)schFeatureParent; pointParent = geoParent.InitialPosition; IPoint pointSon = null; bool enableCalculate = true; ISchematicInMemoryFeature schInMemoryFeature = enumLinks.Next(); ISchematicInMemoryFeatureLink schInMemoryLink = (ISchematicInMemoryFeatureLink)schInMemoryFeature; while (schInMemoryLink != null) { ISchematicInMemoryFeatureNodeGeometry nodeGeo; // get angle of 2 links connected if (schInMemoryLink.FromNode.Name == schFeatureParent.Name) { nodeGeo = (ISchematicInMemoryFeatureNodeGeometry)schInMemoryLink.ToNode; } else { nodeGeo = (ISchematicInMemoryFeatureNodeGeometry)schInMemoryLink.FromNode; } if (nodeGeo == null) { enableCalculate = false; break; } pointSon = nodeGeo.InitialPosition; if (first) { angle1 = CalculateAngle(pointParent, pointSon); first = false; } else { angle2 = CalculateAngle(pointParent, pointSon); } schInMemoryFeature = enumLinks.Next(); schInMemoryLink = (ISchematicInMemoryFeatureLink)schInMemoryFeature; } // caculate angle bisector if (enableCalculate) { angleBisector = CalculateAngleBisector(angle1, angle2); } else { continue; } // construct a geometry for the new node node // now call alterNode to create a new schematic feature // construct a correct name string uniqueNodeName, featureCreateName; featureCreateName = schFeatureParent.Name + Separator + extensionName; esriSchematicElementType elementType = esriSchematicElementType.esriSchematicNodeType; uniqueNodeName = GetUniqueName(inMemoryDiagram, elementType, featureCreateName); IWorkspace workspace = null; try { workspace = inMemoryDiagram.SchematicDiagramClass.SchematicDataset.SchematicWorkspace.Workspace; } catch { } int datasourceID = -1; if (workspace != null) { datasourceID = rulesHelper.FindDataSourceID(workspace, false); } if (datasourceID == -1) { datasourceID = m_diagramClass.SchematicDataset.DefaultSchematicDataSource.ID; } ISchematicInMemoryFeature schFeatureNodeCreate = null; IPoint pointBisector = null; pointBisector = GetCoordPointBisector(pointParent, angleBisector, m_distance); try { schFeatureNodeCreate = rulesHelper.AlterNode(m_targetNodeClass, uniqueNodeName, null, (IGeometry)pointBisector, datasourceID, 0); } catch (Exception ex) { System.Diagnostics.Trace.WriteLine(ex.Message, "Impossible to create a feature Node"); } // now construct a unique link name string linkName = schFeatureParent.Name + Separator + uniqueNodeName; string uniqueLinkName; elementType = esriSchematicElementType.esriSchematicLinkType; uniqueLinkName = GetUniqueName(inMemoryDiagram, elementType, linkName); // construct a link ISchematicInMemoryFeature schFeatureLinkCreate = null; try { schFeatureLinkCreate = rulesHelper.AlterLink(m_targetLinkClass, uniqueLinkName, null, null, datasourceID, 0, schFeatureParent.Name, uniqueNodeName, esriFlowDirection.esriFDWithFlow, 0, 0); } catch (Exception ex) { System.Diagnostics.Trace.WriteLine(ex.Message, "Impossible to create a feature link"); } } if (colSchfeatureNode.Count > 0) { colSchfeatureNode.Clear(); } colSchfeatureNode = null; rulesHelper = null; }
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message) { try { IGPUtilities3 execute_Utilities = new GPUtilitiesClass(); if (TrackCancel == null) { TrackCancel = new CancelTrackerClass(); } IGPParameter inputOSMParameter = paramvalues.get_Element(in_osmFeatureClass) as IGPParameter; IGPValue inputOSMGPValue = execute_Utilities.UnpackGPValue(inputOSMParameter); IGPParameter tagCollectionParameter = paramvalues.get_Element(in_attributeSelector) as IGPParameter; IGPMultiValue tagCollectionGPValue = execute_Utilities.UnpackGPValue(tagCollectionParameter) as IGPMultiValue; if (tagCollectionGPValue == null) { message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), tagCollectionParameter.Name)); return; } bool useUpdateCursor = false; IFeatureClass osmFeatureClass = null; ITable osmInputTable = null; IQueryFilter osmQueryFilter = null; try { execute_Utilities.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter); if (osmFeatureClass != null) { if (osmFeatureClass.Extension is IOSMClassExtension) { useUpdateCursor = false; } else { useUpdateCursor = true; } } osmInputTable = osmFeatureClass as ITable; } catch { } try { if (osmInputTable == null) { execute_Utilities.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter); } } catch { } if (osmInputTable == null) { string errorMessage = String.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelecto_unableopentable"), inputOSMGPValue.GetAsText()); message.AddError(120053, errorMessage); return; } // find the field that holds tag binary/xml field int osmTagCollectionFieldIndex = osmInputTable.FindField("osmTags"); // if the Field doesn't exist - wasn't found (index = -1) get out if (osmTagCollectionFieldIndex == -1) { message.AddError(120005, resourceManager.GetString("GPTools_OSMGPAttributeSelector_notagfieldfound")); return; } // check if the tag collection includes the keyword "ALL", if does then we'll need to extract all tags bool extractAll = false; for (int valueIndex = 0; valueIndex < tagCollectionGPValue.Count; valueIndex++) { if (tagCollectionGPValue.get_Value(valueIndex).GetAsText().Equals("ALL")) { extractAll = true; break; } } //if (extractAll) //{ // if (osmTagKeyCodedValues == null) // extractAllTags(ref osmTagKeyCodedValues, osmInputTable, osmQueryFilter, osmTagCollectionFieldIndex, false); // if (osmTagKeyCodedValues == null) // { // message.AddAbort(resourceManager.GetString("GPTools_OSMGPAttributeSelector_Unable2RetrieveTags")); // return; // } // // empty the existing gp multivalue object // tagCollectionGPValue = new GPMultiValueClass(); // // fill the coded domain in gp multivalue object // for (int valueIndex = 0; valueIndex < osmTagKeyCodedValues.CodeCount; valueIndex++) // { // tagCollectionGPValue.AddValue(osmTagKeyCodedValues.get_Value(valueIndex)); // } //} // get an overall feature count as that determines the progress indicator int featureCount = osmInputTable.RowCount(osmQueryFilter); // set up the progress indicator IStepProgressor stepProgressor = TrackCancel as IStepProgressor; if (stepProgressor != null) { stepProgressor.MinRange = 0; stepProgressor.MaxRange = featureCount; stepProgressor.Position = 0; stepProgressor.Message = resourceManager.GetString("GPTools_OSMGPAttributeSelector_progressMessage"); stepProgressor.StepValue = 1; stepProgressor.Show(); } // let's get all the indices of the desired fields // if the field already exists get the index and if it doesn't exist create it Dictionary <string, int> tagsAttributesIndices = new Dictionary <string, int>(); Dictionary <int, int> attributeFieldLength = new Dictionary <int, int>(); IFeatureWorkspaceManage featureWorkspaceManage = ((IDataset)osmInputTable).Workspace as IFeatureWorkspaceManage; String illegalCharacters = String.Empty; ISQLSyntax sqlSyntax = ((IDataset)osmInputTable).Workspace as ISQLSyntax; if (sqlSyntax != null) { illegalCharacters = sqlSyntax.GetInvalidCharacters(); } IFieldsEdit fieldsEdit = osmInputTable.Fields as IFieldsEdit; using (SchemaLockManager lockMgr = new SchemaLockManager(osmInputTable)) { try { string tagKey = String.Empty; ESRI.ArcGIS.Geoprocessing.IGeoProcessor2 gp = new ESRI.ArcGIS.Geoprocessing.GeoProcessorClass(); // if we have explicitly defined tags to extract then go through the list of values now if (extractAll == false) { for (int valueIndex = 0; valueIndex < tagCollectionGPValue.Count; valueIndex++) { if (TrackCancel.Continue() == false) { return; } try { // Check if the input field already exists. string nameofTag = tagCollectionGPValue.get_Value(valueIndex).GetAsText(); tagKey = convert2AttributeFieldName(nameofTag, illegalCharacters); int fieldIndex = osmInputTable.FindField(tagKey); if (fieldIndex < 0) { // generate a new attribute field IFieldEdit fieldEdit = new FieldClass(); fieldEdit.Name_2 = tagKey; fieldEdit.AliasName_2 = nameofTag + resourceManager.GetString("GPTools_OSMGPAttributeSelector_aliasaddition"); fieldEdit.Type_2 = esriFieldType.esriFieldTypeString; fieldEdit.Length_2 = 100; osmInputTable.AddField(fieldEdit); message.AddMessage(string.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelector_addField"), tagKey, nameofTag)); // re-generate the attribute index fieldIndex = osmInputTable.FindField(tagKey); } if (fieldIndex > 0) { tagsAttributesIndices.Add(nameofTag, fieldIndex); attributeFieldLength.Add(fieldIndex, osmInputTable.Fields.get_Field(fieldIndex).Length); } } catch (Exception ex) { // the key is already there, this might result because from multiple upper and lower-case combinations of the same key message.AddWarning(ex.Message + " (" + convert2OSMKey(tagKey, illegalCharacters) + ")"); } } } else { List <string> listofAllTags = extractAllTags(osmInputTable, osmQueryFilter, osmTagCollectionFieldIndex); foreach (string nameOfTag in listofAllTags) { if (TrackCancel.Continue() == false) { return; } try { // Check if the input field already exists. tagKey = convert2AttributeFieldName(nameOfTag, illegalCharacters); int fieldIndex = osmInputTable.FindField(tagKey); if (fieldIndex < 0) { // generate a new attribute field IFieldEdit fieldEdit = new FieldClass(); fieldEdit.Name_2 = tagKey; fieldEdit.AliasName_2 = nameOfTag + resourceManager.GetString("GPTools_OSMGPAttributeSelector_aliasaddition"); fieldEdit.Type_2 = esriFieldType.esriFieldTypeString; fieldEdit.Length_2 = 100; osmInputTable.AddField(fieldEdit); message.AddMessage(string.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelector_addField"), tagKey, nameOfTag)); // re-generate the attribute index fieldIndex = osmInputTable.FindField(tagKey); } if (fieldIndex > 0) { tagsAttributesIndices.Add(nameOfTag, fieldIndex); attributeFieldLength.Add(fieldIndex, osmInputTable.Fields.get_Field(fieldIndex).Length); } } catch (Exception ex) { // the key is already there, this might result because from multiple upper and lower-case combinations of the same key message.AddWarning(ex.Message + " (" + convert2OSMKey(tagKey, illegalCharacters) + ")"); } } } } catch (Exception ex) { message.AddWarning(ex.Message); } } try { execute_Utilities.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter); if (osmFeatureClass != null) { if (osmFeatureClass.Extension is IOSMClassExtension) { useUpdateCursor = false; } else { useUpdateCursor = true; } } osmInputTable = osmFeatureClass as ITable; } catch { } try { if (osmInputTable == null) { execute_Utilities.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter); } } catch { } if (osmInputTable == null) { string errorMessage = String.Format(resourceManager.GetString("GPTools_OSMGPAttributeSelecto_unableopentable"), inputOSMGPValue.GetAsText()); message.AddError(120053, errorMessage); return; } using (ComReleaser comReleaser = new ComReleaser()) { using (SchemaLockManager lockMgr = new SchemaLockManager(osmInputTable)) { // get an update cursor for all the features to process ICursor rowCursor = null; if (useUpdateCursor) { rowCursor = osmInputTable.Update(osmQueryFilter, false); } else { rowCursor = osmInputTable.Search(osmQueryFilter, false); } comReleaser.ManageLifetime(rowCursor); IRow osmRow = null; Dictionary <string, string> tagKeys = new Dictionary <string, string>(); int progessIndex = 0; #if DEBUG message.AddMessage("useUpdateCursor: " + useUpdateCursor.ToString()); #endif // as long as there are features.... while ((osmRow = rowCursor.NextRow()) != null) { // retrieve the tags of the current feature tag[] storedTags = _osmUtility.retrieveOSMTags(osmRow, osmTagCollectionFieldIndex, ((IDataset)osmInputTable).Workspace); bool rowChanged = false; if (storedTags != null) { foreach (tag tagItem in storedTags) { // Check for matching values so we only change a minimum number of rows if (tagsAttributesIndices.ContainsKey(tagItem.k)) { int fieldIndex = tagsAttributesIndices[tagItem.k]; //...then stored the value in the attribute field // ensure that the content of the tag actually does fit into the field length...otherwise do truncate it string tagValue = tagItem.v; int fieldLength = attributeFieldLength[fieldIndex]; if (tagValue.Length > fieldLength) { tagValue = tagValue.Substring(0, fieldLength); } osmRow.set_Value(fieldIndex, tagValue); rowChanged = true; } else { #if DEBUG //message.AddWarning(tagItem.k); #endif } } } storedTags = null; try { if (rowChanged) { if (useUpdateCursor) { rowCursor.UpdateRow(osmRow); } else { // update the feature through the cursor osmRow.Store(); } } progessIndex++; } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); message.AddWarning(ex.Message); } if (osmRow != null) { Marshal.ReleaseComObject(osmRow); } if (stepProgressor != null) { // update the progress UI stepProgressor.Position = progessIndex; } // check for user cancellation (every 100 rows) if ((progessIndex % 100 == 0) && (TrackCancel.Continue() == false)) { return; } } if (stepProgressor != null) { stepProgressor.Hide(); } } } execute_Utilities.ReleaseInternals(); Marshal.ReleaseComObject(execute_Utilities); } catch (Exception ex) { message.AddError(120054, ex.Message); } }
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message) { try { IGPUtilities3 gpUtilities3 = new GPUtilitiesClass(); if (TrackCancel == null) { TrackCancel = new CancelTrackerClass(); } IGPValue inputLayersGPValue = gpUtilities3.UnpackGPValue(paramvalues.get_Element(in_LayersNumber)); IGPMultiValue inputLayersMultiValue = gpUtilities3.UnpackGPValue(inputLayersGPValue) as IGPMultiValue; IGPParameter outputGroupLayerParameter = paramvalues.get_Element(out_groupLayerNumber) as IGPParameter; IGPValue outputGPGroupLayer = gpUtilities3.UnpackGPValue(outputGroupLayerParameter); IGPCompositeLayer outputCompositeLayer = outputGPGroupLayer as IGPCompositeLayer; if (outputCompositeLayer == null) { message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), outputGroupLayerParameter.Name)); return; } IGroupLayer groupLayer = null; // find the last position of the "\" string // in case we find such a thing, i.e. position is >= -1 then let's assume that we are dealing with a layer file on disk // otherwise let's create a new group layer instance string outputGPLayerNameAsString = outputGPGroupLayer.GetAsText(); int separatorPosition = outputGPLayerNameAsString.LastIndexOf(System.IO.Path.DirectorySeparatorChar); string layerName = String.Empty; if (separatorPosition > -1) { layerName = outputGPGroupLayer.GetAsText().Substring(separatorPosition + 1); } else { layerName = outputGPGroupLayer.GetAsText(); } ILayer foundLayer = null; IGPLayer existingGPLayer = gpUtilities3.FindMapLayer2(layerName, out foundLayer); if (foundLayer != null) { gpUtilities3.RemoveFromMapEx((IGPValue)existingGPLayer); gpUtilities3.RemoveInternalLayerEx(foundLayer); } groupLayer = new GroupLayer(); ((ILayer)groupLayer).Name = layerName; for (int layerIndex = 0; layerIndex < inputLayersMultiValue.Count; layerIndex++) { IGPValue gpLayerToAdd = inputLayersMultiValue.get_Value(layerIndex) as IGPValue; ILayer sourceLayer = gpUtilities3.DecodeLayer(gpLayerToAdd); groupLayer.Add(sourceLayer); } outputGPGroupLayer = gpUtilities3.MakeGPValueFromObject(groupLayer); if (separatorPosition > -1) { try { // in the case that we are dealing with a layer file on disk // let's persist the group layer information into the file ILayerFile pointLayerFile = new LayerFileClass(); if (System.IO.Path.GetExtension(outputGPLayerNameAsString).ToUpper().Equals(".LYR")) { if (pointLayerFile.get_IsPresent(outputGPLayerNameAsString)) { try { gpUtilities3.Delete(outputGPGroupLayer); } catch (Exception ex) { message.AddError(120001, ex.Message); return; } } pointLayerFile.New(outputGPLayerNameAsString); pointLayerFile.ReplaceContents(groupLayer); pointLayerFile.Save(); } outputGPGroupLayer = gpUtilities3.MakeGPValueFromObject(pointLayerFile.Layer); } catch (Exception ex) { message.AddError(120002, ex.Message); return; } } gpUtilities3.PackGPValue(outputGPGroupLayer, outputGroupLayerParameter); } catch (Exception ex) { message.AddError(120049, ex.Message); } }
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message) { try { IGPUtilities3 gpUtilities3 = new GPUtilitiesClass(); if (TrackCancel == null) { TrackCancel = new CancelTrackerClass(); } // find feature class inside the given feature dataset IGPParameter osmFeatureDatasetParameter = paramvalues.get_Element(in_osmFeatureDatasetNumber) as IGPParameter; IDEFeatureDataset osmFeatureDataset = gpUtilities3.UnpackGPValue(osmFeatureDatasetParameter) as IDEFeatureDataset; string osmPointFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_pt"; string osmLineFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ln"; string osmPolygonFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ply"; IFeatureClass osmPointFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPointFeatureClassString); IFeatureClass osmLineFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmLineFeatureClassString); IFeatureClass osmPoylgonFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPolygonFeatureClassString); // open the specified layers holding the symbology and editing templates IGPParameter osmPointSymbolTemplateParameter = paramvalues.get_Element(in_osmPointLayerNumber) as IGPParameter; IGPValue osmGPPointLayerValue = gpUtilities3.UnpackGPValue(osmPointSymbolTemplateParameter); IGPParameter outputPointGPParameter = paramvalues.get_Element(out_osmPointLayerNumber) as IGPParameter; IGPValue outputPointLayerGPValue = gpUtilities3.UnpackGPValue(outputPointGPParameter); bool isLayerOnDisk = false; // create a clone of the source layer // we will then go ahead and adjust the data source (dataset) of the cloned layer IObjectCopy objectCopy = new ObjectCopyClass(); ICompositeLayer adjustedPointTemplateLayer = objectCopy.Copy(osmGPPointLayerValue) as ICompositeLayer; IGPGroupLayer osmPointGroupTemplateLayer = adjustedPointTemplateLayer as IGPGroupLayer; ICompositeLayer compositeLayer = gpUtilities3.Open((IGPValue)osmPointGroupTemplateLayer) as ICompositeLayer; //ICompositeLayer adjustedPointTemplateLayer = osmGPPointLayerValue as ICompositeLayer; //IGPGroupLayer osmPointGroupTemplateLayer = osmGPPointLayerValue as IGPGroupLayer; //IClone cloneSource = osmPointGroupTemplateLayer as IClone; //ICompositeLayer compositeLayer = m_gpUtilities3.Open((IGPValue)cloneSource.Clone()) as ICompositeLayer; if (compositeLayer == null) { ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass(); IFileName layerFileName = new FileNameClass(); layerFileName.Path = osmGPPointLayerValue.GetAsText(); IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName); enumLayer.Reset(); compositeLayer = enumLayer.Next() as ICompositeLayer; isLayerOnDisk = true; } IFeatureLayerDefinition2 featureLayerDefinition2 = null; ISQLSyntax sqlSyntax = null; IGPLayer adjustedPointGPLayer = null; if (compositeLayer != null) { for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++) { IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2; if (geoFeatureLayer != null) { if (geoFeatureLayer.ShapeType == osmPointFeatureClass.ShapeType) { try { ((IDataLayer2)geoFeatureLayer).Disconnect(); } catch { } ((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPointFeatureClass).FullName; ((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPointFeatureClass).FullName); featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2; if (featureLayerDefinition2 != null) { string queryDefinition = featureLayerDefinition2.DefinitionExpression; sqlSyntax = ((IDataset)osmPointFeatureClass).Workspace as ISQLSyntax; string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix); if (String.IsNullOrEmpty(queryDefinition) == false) { string stringToReplace = queryDefinition.Substring(0, 1); queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier); } featureLayerDefinition2.DefinitionExpression = queryDefinition; } } } } adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer); // save the newly adjusted layer information to disk if (isLayerOnDisk == true) { ILayerFile pointLayerFile = new LayerFileClass(); if (pointLayerFile.get_IsPresent(outputPointLayerGPValue.GetAsText())) { try { File.Delete(outputPointLayerGPValue.GetAsText()); } catch (Exception ex) { message.AddError(120041, ex.Message); return; } } pointLayerFile.New(outputPointLayerGPValue.GetAsText()); pointLayerFile.ReplaceContents((ILayer)compositeLayer); pointLayerFile.Save(); adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)pointLayerFile.Layer); } // IGPLayer adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer); gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPointGPLayer); gpUtilities3.PackGPValue((IGPValue)adjustedPointGPLayer, outputPointGPParameter); } isLayerOnDisk = false; IGPParameter osmLineSymbolTemplateParameter = paramvalues.get_Element(in_osmLineLayerNumber) as IGPParameter; IGPValue osmGPLineLayerValue = gpUtilities3.UnpackGPValue(osmLineSymbolTemplateParameter) as IGPValue; IGPParameter outputLineGPParameter = paramvalues.get_Element(out_osmLineLayerNumber) as IGPParameter; IGPValue outputLineLayerGPValue = gpUtilities3.UnpackGPValue(outputLineGPParameter); IGPValue adjustedLineTemplateLayer = objectCopy.Copy(osmGPLineLayerValue) as IGPValue; IGPGroupLayer osmLineGroupTemplateLayer = adjustedLineTemplateLayer as IGPGroupLayer; compositeLayer = gpUtilities3.Open((IGPValue)osmLineGroupTemplateLayer) as ICompositeLayer; if (compositeLayer == null) { ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass(); IFileName layerFileName = new FileNameClass(); layerFileName.Path = osmGPLineLayerValue.GetAsText(); IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName); enumLayer.Reset(); compositeLayer = enumLayer.Next() as ICompositeLayer; isLayerOnDisk = true; } if (compositeLayer != null) { for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++) { IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2; if (geoFeatureLayer.ShapeType == osmLineFeatureClass.ShapeType) { try { ((IDataLayer2)geoFeatureLayer).Disconnect(); } catch { } ((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmLineFeatureClass).FullName; ((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmLineFeatureClass).FullName); featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2; if (featureLayerDefinition2 != null) { string queryDefinition = featureLayerDefinition2.DefinitionExpression; sqlSyntax = ((IDataset)osmLineFeatureClass).Workspace as ISQLSyntax; string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix); if (string.IsNullOrEmpty(queryDefinition) == false) { string stringToReplace = queryDefinition.Substring(0, 1); queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier); } featureLayerDefinition2.DefinitionExpression = queryDefinition; } } } // save the newly adjusted layer information to disk if (isLayerOnDisk == true) { ILayerFile lineLayerFile = new LayerFileClass(); if (lineLayerFile.get_IsPresent(outputLineLayerGPValue.GetAsText())) { try { File.Delete(outputLineLayerGPValue.GetAsText()); } catch (Exception ex) { message.AddError(120042, ex.Message); return; } } lineLayerFile.New(outputLineLayerGPValue.GetAsText()); lineLayerFile.ReplaceContents((ILayer)compositeLayer); lineLayerFile.Save(); } IGPLayer adjustLineGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer); gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustLineGPLayer); gpUtilities3.PackGPValue((IGPValue)adjustLineGPLayer, outputLineGPParameter); } isLayerOnDisk = false; IGPParameter osmPolygonSymbolTemplateParameter = paramvalues.get_Element(in_osmPolygonLayerNumber) as IGPParameter; IGPValue osmGPPolygonLayerValue = gpUtilities3.UnpackGPValue(osmPolygonSymbolTemplateParameter); IGPParameter outputPolygonGPParameter = paramvalues.get_Element(out_osmPolygonLayerNumber) as IGPParameter; IGPValue outputPolygonLayerGPValue = gpUtilities3.UnpackGPValue(outputPolygonGPParameter); IGPValue adjustedPolygonTemplateLayer = objectCopy.Copy(osmGPPolygonLayerValue) as IGPValue; IGPGroupLayer osmPolygonGroupTemplateLayer = adjustedPolygonTemplateLayer as IGPGroupLayer; compositeLayer = gpUtilities3.Open((IGPValue)osmPolygonGroupTemplateLayer) as ICompositeLayer; if (compositeLayer == null) { ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass(); IFileName layerFileName = new FileNameClass(); layerFileName.Path = osmGPPolygonLayerValue.GetAsText(); IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName); enumLayer.Reset(); compositeLayer = enumLayer.Next() as ICompositeLayer; isLayerOnDisk = true; } if (compositeLayer != null) { for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++) { IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2; if (geoFeatureLayer.ShapeType == osmPoylgonFeatureClass.ShapeType) { try { ((IDataLayer2)geoFeatureLayer).Disconnect(); } catch { } ((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPoylgonFeatureClass).FullName; ((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPoylgonFeatureClass).FullName); featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2; if (featureLayerDefinition2 != null) { string queryDefinition = featureLayerDefinition2.DefinitionExpression; sqlSyntax = ((IDataset)osmPoylgonFeatureClass).Workspace as ISQLSyntax; string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix); if (String.IsNullOrEmpty(queryDefinition) == false) { string stringToReplace = queryDefinition.Substring(0, 1); queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier); } featureLayerDefinition2.DefinitionExpression = queryDefinition; } } } // save the newly adjusted layer information to disk if (isLayerOnDisk == true) { ILayerFile polygonLayerFile = new LayerFileClass(); if (polygonLayerFile.get_IsPresent(outputPolygonLayerGPValue.GetAsText())) { try { File.Delete(outputPolygonLayerGPValue.GetAsText()); } catch (Exception ex) { message.AddError(120043, ex.Message); return; } } polygonLayerFile.New(outputPolygonLayerGPValue.GetAsText()); polygonLayerFile.ReplaceContents((ILayer)compositeLayer); polygonLayerFile.Save(); } IGPLayer adjustedPolygonGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer); gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPolygonGPLayer); gpUtilities3.PackGPValue((IGPValue)adjustedPolygonGPLayer, outputPolygonGPParameter); } } catch (Exception ex) { message.AddError(-10, ex.Message); } }
void IFeatureRenderer.Draw(ESRI.ArcGIS.Geodatabase.IFeatureCursor Cursor, ESRI.ArcGIS.esriSystem.esriDrawPhase DrawPhase, IDisplay Display, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel) { // do not draw features if no display if (Display == null) { return; } else { clsSnippet pSnippet = new clsSnippet(); IFeature pFeat = null; intBrksCount = pCSMembers.ClassBrks.Length - 1; ISimpleFillSymbol pSFillSym = new SimpleFillSymbolClass(); ICartographicLineSymbol pOutLines = new CartographicLineSymbol(); pOutLines.Width = dblLineWidth; pOutLines.Color = (IColor)pLineRgb; pFeat = Cursor.NextFeature(); IRgbColor pRGBColor = null; int i = 0; double dblValue = 0; //Start Loop while (pFeat != null) { dblValue = Convert.ToDouble(pFeat.get_Value(intEstIdx)); IFeatureDraw pFeatDraw = (IFeatureDraw)pFeat; pSFillSym = new SimpleFillSymbolClass(); pSFillSym.Outline = pOutLines; pRGBColor = null; for (int j = 0; j < intBrksCount; j++) { if (j == 0) { if (dblValue >= pCSMembers.ClassBrks[0] && dblValue <= pCSMembers.ClassBrks[1]) { pRGBColor = pSnippet.getRGB(pCSMembers.Colors[0, 0], pCSMembers.Colors[0, 1], pCSMembers.Colors[0, 2]); } } else { if (dblValue > pCSMembers.ClassBrks[j] && dblValue <= pCSMembers.ClassBrks[j + 1]) { pRGBColor = pSnippet.getRGB(pCSMembers.Colors[j, 0], pCSMembers.Colors[j, 1], pCSMembers.Colors[j, 2]); } } } pSFillSym.Color = (IColor)pRGBColor; Display.SetSymbol((ISymbol)pSFillSym); pFeatDraw.Draw(esriDrawPhase.esriDPGeography, Display, (ISymbol)pSFillSym, true, null, esriDrawStyle.esriDSNormal); i++; pFeat = Cursor.NextFeature(); } } }