public ProgressDialog(bool a_EnableCancel, int a_MinValue, int a_MaxValue, string a_Title, string a_Description) { var a_ProgressDialogFactory = new ProgressDialogFactoryClass(); m_TrackCancel = new CancelTracker(); m_StepProgressor = a_ProgressDialogFactory.Create(m_TrackCancel, 0); m_ProgressDialog = (IProgressDialog2)m_StepProgressor; m_TrackCancel.CancelOnClick = a_EnableCancel; m_TrackCancel.CancelOnKeyPress = a_EnableCancel; m_StepProgressor.MinRange = a_MinValue; m_StepProgressor.MaxRange = a_MaxValue; m_StepProgressor.StepValue = 1; m_StepProgressor.Position = m_StepProgressor.MinRange; if (a_MinValue == a_MaxValue) { m_StepProgressor.Hide(); } m_ProgressDialog.CancelEnabled = a_EnableCancel; m_ProgressDialog.Title = a_Title; m_ProgressDialog.Description = a_Description; m_ProgressDialog.Animation = esriProgressAnimationTypes.esriProgressSpiral; }
/// <summary> /// Releases unmanaged and - optionally - managed resources. /// </summary> /// <param name="disposing"> /// <c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only /// unmanaged resources. /// </param> protected override void Dispose(bool disposing) { base.Dispose(disposing); if (disposing) { _ProgressBar.Hide(); } }
/// <summary>Exports all bookmarks to PDF files.</summary> /// <param name="directory">The directory that the exported files will be written to.</param> /// <param name="dpi">The resolution of the output files.</param> /// <param name="exportFormat">The format of the exported files.</param> public void ExportBookmarksToFiles(string directory, long dpi, ExportFormat exportFormat) { if (!Directory.Exists(directory)) { throw new DirectoryNotFoundException("Directory not found: " + directory); } IMouseCursor mc = new MouseCursorClass(); const int hourglass = 2; mc.SetCursor(hourglass); IMxDocument mxDoc = _app.Document as IMxDocument; IMapBookmarks bookmarks = (IMapBookmarks)mxDoc.FocusMap; IEnumSpatialBookmark enumBM = bookmarks.Bookmarks; enumBM.Reset(); ISpatialBookmark sbm = enumBM.Next(); ProgressDialogFactoryClass dialogFactory = new ProgressDialogFactoryClass(); var cancelTracker = new CancelTrackerClass(); IStepProgressor stepProgressor = dialogFactory.Create(cancelTracker, _app.hWnd); IProgressDialog2 progDialog = stepProgressor as IProgressDialog2; progDialog.CancelEnabled = true; progDialog.ShowDialog(); stepProgressor.Hide(); stepProgressor.Message = "Exporting..."; // Create a formatting string with the proper extension. (E.g., "{0}.pdf" for PDF files".) string fnFmt = string.Format("{{0}}.{0}", Enum.GetName(typeof(ExportFormat), exportFormat)); try { while (sbm != null) { sbm.ZoomTo(mxDoc.FocusMap); string filename = System.IO.Path.Combine(directory, string.Format(fnFmt, sbm.Name)); ExportPageLayoutToFile(mxDoc.PageLayout, filename, dpi, exportFormat); sbm = enumBM.Next(); } } finally { if (progDialog != null) { progDialog.HideDialog(); ComReleaser.ReleaseCOMObject(progDialog); } } }
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); } }
// Execute: Execute the function given the array of the parameters public void Execute(IArray paramvalues, ITrackCancel trackcancel, IGPEnvironmentManager envMgr, IGPMessages message) { IFeatureClass outputFeatureClass = null; try { // get the input feature class IGPMultiValue inputFeatureClasses_Parameter = (IGPMultiValue)m_GPUtilities.UnpackGPValue(paramvalues.get_Element(0)); layer[] input_featureClasses = new layer[inputFeatureClasses_Parameter.Count]; for (int i = 0; i < inputFeatureClasses_Parameter.Count; i++) { IGPValue inputFeatureClass_Parameter = inputFeatureClasses_Parameter.get_Value(i); IFeatureClass inputFeatureClass; IQueryFilter inputQF; m_GPUtilities.DecodeFeatureLayer(inputFeatureClass_Parameter, out inputFeatureClass, out inputQF); input_featureClasses[i] = new layer() { featureclass = inputFeatureClass, qFilter = inputQF }; } if (input_featureClasses.Length == 0 || input_featureClasses.Any(w => w.featureclass == null)) { message.AddError(2, "Could not open one or more input dataset."); return; } //IFields additionalFields = new FieldsClass(); //additionalFields.AddField(FEATURE_SOURCE_FIELD_NAME, esriFieldType.esriFieldTypeString); //additionalFields.AddField(FEATURE_ID_FIELD_NAME, esriFieldType.esriFieldTypeInteger); //additionalFields.AddField( // input_featureClasses[0].featureclass.Fields.get_Field( // input_featureClasses[0].featureclass.Fields.FindField( // input_featureClasses[0].featureclass.ShapeFieldName))); // create the output feature class IGPValue outputFeatureClass_Parameter = m_GPUtilities.UnpackGPValue(paramvalues.get_Element(1)); outputFeatureClass = GPHelperFunctions.CreateFeatureClass(outputFeatureClass_Parameter, envMgr); if (outputFeatureClass == null) { message.AddError(2, "Could not create output dataset."); return; } IGPString curveTypeParameter = (IGPString)m_GPUtilities.UnpackGPValue(paramvalues.get_Element(2)); ArcConstructionMethods method; if (!Enum.TryParse <ArcConstructionMethods>(curveTypeParameter.Value, true, out method)) { message.AddError(2, string.Format("The value {0} is not expected. Expected values are: {1}.", curveTypeParameter.Value, string.Join(",", Enum.GetNames(typeof(ArcConstructionMethods))))); return; } IStepProgressor stepPro = (IStepProgressor)trackcancel; GPHelperFunctions.dropSpatialIndex(outputFeatureClass); BoostVoronoi bv = new BoostVoronoi(100); double minX = int.MaxValue, minY = int.MaxValue, maxX = int.MinValue, maxY = int.MinValue; List <site_key> point_sites = new List <site_key>(); List <site_key> segment_sites = new List <site_key>(); for (short i = 0; i < input_featureClasses.Length; i++) { layer l = input_featureClasses[i]; int featcount = l.featureclass.FeatureCount(l.qFilter); stepPro.MinRange = 0; stepPro.MaxRange = featcount; stepPro.StepValue = (1); stepPro.Message = "Reading features"; stepPro.Position = 0; stepPro.Show(); IFeatureCursor cursor = null; IFeature row = null; try { cursor = l.featureclass.Search(l.qFilter, false); while ((row = cursor.NextFeature()) != null) { stepPro.Step(); IPoint point = row.Shape as IPoint; if (point != null) { double X = point.X; double Y = point.Y; minX = Math.Min(minX, X); maxX = Math.Max(maxX, X); minY = Math.Min(minY, Y); maxY = Math.Max(maxY, Y); bv.AddPoint(point.X, point.Y); point_sites.Add(new site_key(i, row.OID)); } IMultipoint multipoint = row.Shape as IMultipoint; if (multipoint != null) { IPointCollection pointCollection = (IPointCollection)multipoint; IEnumVertex vertices = pointCollection.EnumVertices; IPoint vertex = null; int part, index; vertices.Next(out vertex, out part, out index); minX = Math.Min(minX, multipoint.Envelope.XMin); maxX = Math.Max(maxX, multipoint.Envelope.XMax); minY = Math.Min(minY, multipoint.Envelope.YMin); maxY = Math.Max(maxY, multipoint.Envelope.YMax); while (vertex != null) { bv.AddPoint(vertex.X, vertex.Y); point_sites.Add(new site_key(i, row.OID)); vertices.Next(out vertex, out part, out index); } } IPolyline polyline = row.Shape as IPolyline; if (polyline != null) { double fromX = polyline.FromPoint.X; double fromY = polyline.FromPoint.Y; double toX = polyline.ToPoint.X; double toY = polyline.ToPoint.Y; if (toX < fromX) { minX = Math.Min(minX, toX); maxX = Math.Max(maxX, fromX); } else { minX = Math.Min(minX, fromX); maxX = Math.Max(maxX, toX); } if (toY < fromY) { minY = Math.Min(minY, toY); maxY = Math.Max(maxY, fromY); } else { minY = Math.Min(minY, fromY); maxY = Math.Max(maxY, toY); } bv.AddSegment( polyline.FromPoint.X, polyline.FromPoint.Y, polyline.ToPoint.X, polyline.ToPoint.Y ); segment_sites.Add(new site_key(i, row.OID)); } Marshal.ReleaseComObject(row); } } finally { if (row != null) { Marshal.ReleaseComObject(row); } if (cursor != null) { Marshal.ReleaseComObject(cursor); } stepPro.Hide(); } } message.AddMessage(String.Format("{0}, {1} -> {2}, {3}", minX, minY, maxX, maxY)); int width = Math.Max((int)((maxX - minX) * 0.1), 1); int height = Math.Max((int)((maxY - minY) * 0.1), 1); maxX = maxX + width; minX = minX - width; maxY = maxY + height; minY = minY - height; message.AddMessage(String.Format("{0}, {1} -> {2}, {3}", minX, minY, maxX, maxY)); bv.AddSegment(minX, minY, maxX, minY); segment_sites.Add(new site_key(-1, -1)); bv.AddSegment(maxX, minY, maxX, maxY); segment_sites.Add(new site_key(-1, -1)); bv.AddSegment(maxX, maxY, minX, maxY); segment_sites.Add(new site_key(-1, -1)); bv.AddSegment(minX, maxY, minX, minY); segment_sites.Add(new site_key(-1, -1)); stepPro.Message = "Solve Voronoi"; stepPro.MaxRange = 0; stepPro.MaxRange = 0; stepPro.Show(); bv.Construct(); stepPro.Hide(); int featureSourceIndx = outputFeatureClass.Fields.FindField(FEATURE_SOURCE_FIELD_NAME); int featureIDIndx = outputFeatureClass.Fields.FindField(FEATURE_ID_FIELD_NAME); IFeatureCursor inserts = null; IFeatureBuffer buffer = null; try { object missing = Type.Missing; ISpatialReference spatialReference = ((IGeoDataset)outputFeatureClass).SpatialReference; inserts = outputFeatureClass.Insert(false); buffer = outputFeatureClass.CreateFeatureBuffer(); List <Cell> cells = bv.Cells; message.AddMessage(string.Format("{0} cells calculated", cells.Count)); List <Edge> edges = bv.Edges; message.AddMessage(string.Format("{0} edges calculated", edges.Count)); List <Vertex> vertices = bv.Vertices; message.AddMessage(string.Format("{0} vertexes calculated", vertices.Count)); stepPro.Message = "Write cells"; stepPro.MaxRange = 0; stepPro.MaxRange = cells.Count; stepPro.Show(); for (int cellIndex = 0; cellIndex < cells.Count; cellIndex++) { try { if (cellIndex % 5000 == 0) { message.AddMessage(String.Format("{0}. {1} cells processed.", DateTime.Now, cellIndex)); } Cell cell = cells[cellIndex]; int currentSite = cell.Site; IGeometryCollection geometryCollection = new GeometryBagClass() { SpatialReference = spatialReference }; //ignores any sliver cells if (cell.IsOpen || cell.EdgesIndex.Count < 3) { continue; } ISegmentCollection segmentCollection = createSegments(cell, bv, method, spatialReference); if (((IArea)segmentCollection).Area <= 0) { message.AddMessage("A invalid geometry has been detected, try reversing the orientation."); ISegmentCollection reversed_segmentCollection = new PolygonClass() { SpatialReference = spatialReference }; for (int i = segmentCollection.SegmentCount - 1; i >= 0; i--) { ISegment segment = (ISegment)segmentCollection.get_Segment(i); segment.ReverseOrientation(); reversed_segmentCollection.AddSegment(segment); } segmentCollection = reversed_segmentCollection; } ((IPolygon)segmentCollection).SpatialReference = spatialReference; if (((IArea)segmentCollection).Area <= 0) { message.AddWarning("An empty shell has been created"); for (int i = 0; i < segmentCollection.SegmentCount; i++) { ISegment segment = (ISegment)segmentCollection.get_Segment(i); message.AddMessage(String.Format("From {0}, {1} To {2},{3}", segment.FromPoint.X, segment.FromPoint.Y, segment.ToPoint.X, segment.ToPoint.Y)); } } //set attributes site_key sk = (currentSite >= point_sites.Count) ? segment_sites[currentSite - point_sites.Count] : point_sites[currentSite]; if (!sk.isEmpty) { buffer.set_Value(featureSourceIndx, input_featureClasses[sk.featureClassIndex].featureclass.AliasName); buffer.set_Value(featureIDIndx, sk.objectID); } else { buffer.set_Value(featureSourceIndx, DBNull.Value); buffer.set_Value(featureIDIndx, DBNull.Value); } IPolygon voronoiPolygon = (IPolygon)segmentCollection; buffer.Shape = (IPolygon)voronoiPolygon; inserts.InsertFeature(buffer); } catch (Exception e) { message.AddWarning("Failed to create a cell"); } } } finally { if (buffer != null) { Marshal.ReleaseComObject(buffer); } if (inserts != null) { Marshal.ReleaseComObject(inserts); } } GPHelperFunctions.createSpatialIndex(outputFeatureClass); } catch (Exception exx) { message.AddError(2, exx.Message); message.AddMessage(exx.ToString()); } finally { if (outputFeatureClass != null) { Marshal.ReleaseComObject(outputFeatureClass); } ((IProgressor)trackcancel).Hide(); } }
// Execute: Execute the function given the array of the parameters public void Execute(IArray paramvalues, ITrackCancel trackcancel, IGPEnvironmentManager envMgr, IGPMessages message) { // Get the first Input Parameter IGPParameter parameter = (IGPParameter)paramvalues.get_Element(0); // UnPackGPValue. This ensures you get the value either form the dataelement or GpVariable (ModelBuilder) IGPValue parameterValue = m_GPUtilities.UnpackGPValue(parameter); // Open Input Dataset IFeatureClass inputFeatureClass; IQueryFilter qf; m_GPUtilities.DecodeFeatureLayer(parameterValue, out inputFeatureClass, out qf); if (inputFeatureClass == null) { message.AddError(2, "Could not open input dataset."); return; } // Add the field if it does not exist. int indexA; parameter = (IGPParameter)paramvalues.get_Element(1); string field = parameter.Value.GetAsText(); indexA = inputFeatureClass.FindField(field); if (indexA < 0) { IFieldEdit fieldEdit = new FieldClass(); fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble; fieldEdit.Name_2 = field; inputFeatureClass.AddField(fieldEdit); } int featcount = inputFeatureClass.FeatureCount(null); //Set the properties of the Step Progressor IStepProgressor pStepPro = (IStepProgressor)trackcancel; pStepPro.MinRange = 0; pStepPro.MaxRange = featcount; pStepPro.StepValue = (1); pStepPro.Message = "Calculating Area"; pStepPro.Position = 0; pStepPro.Show(); // Create an Update Cursor indexA = inputFeatureClass.FindField(field); IFeatureCursor updateCursor = inputFeatureClass.Update(qf, false); IFeature updateFeature = updateCursor.NextFeature(); IGeometry geometry; IArea area; double dArea; while (updateFeature != null) { geometry = updateFeature.Shape; area = (IArea)geometry; dArea = area.Area; updateFeature.set_Value(indexA, dArea); updateCursor.UpdateFeature(updateFeature); updateFeature.Store(); updateFeature = updateCursor.NextFeature(); pStepPro.Step(); } pStepPro.Hide(); // Release the update cursor to remove the lock on the input data. System.Runtime.InteropServices.Marshal.ReleaseComObject(updateCursor); }
public void Draw(IStepProgressor stepProgressor, IActiveView activeView, FileCache fileCache, ITrackCancel trackCancel, ISpatialReference layerSpatialReference, ref string currentLevel, ITileSource tileSource, IDisplay display) { _tileSource = tileSource; _trackCancel = trackCancel; _layerSpatialReference = layerSpatialReference; _currentLevel = currentLevel; _fileCache = fileCache; _tileProvider = (WebTileProvider)tileSource.Provider; var spatialReferences = new SpatialReferences(); _dataSpatialReference = spatialReferences.GetSpatialReference(tileSource.Schema.Srs); //var fetcher = new FileFetcher<Image>(osmTileSource, fileCache); _display = display; if (!activeView.Extent.IsEmpty) { _tiles = GetTiles(activeView); currentLevel = _currentLevel; Logger.Debug("Number of tiles to draw: " + _tiles.Count); if (_tiles.ToList().Count > 0) { stepProgressor.MinRange = 0; stepProgressor.MaxRange = _tiles.ToList().Count; stepProgressor.Show(); var downloadFinished = new ManualResetEvent(false); // this is a hack, otherwise we get error message... // "WaitAll for multiple handles on a STA thread is not supported. (mscorlib)" // so lets start a thread first... var t = new Thread(DownloadTiles); t.Start(downloadFinished); // wait till finished downloadFinished.WaitOne(); // 3. Now draw all tiles... if (layerSpatialReference != null && _dataSpatialReference != null) { _needReproject = (layerSpatialReference.FactoryCode != _dataSpatialReference.FactoryCode); } Logger.Debug("Need reproject tile: " + _needReproject.ToString()); foreach (var tile in _tiles) { stepProgressor.Step(); if (tile != null) { var name = _fileCache.GetFileName(tile.Index); if (!File.Exists(name)) { continue; } DrawRaster(name); } } stepProgressor.Hide(); } else { Logger.Debug("No tiles to retrieve or draw"); } Logger.Debug("End drawing tiles: " + _tiles.ToList().Count); } }
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); } }
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 Draw(IStepProgressor stepProgressor, IActiveView activeView, FileCache fileCache, ITrackCancel trackCancel, ISpatialReference layerSpatialReference, ref string currentLevel, ITileSource tileSource, IDisplay display) { _tileSource = tileSource; _trackCancel = trackCancel; _layerSpatialReference = layerSpatialReference; _currentLevel = currentLevel; _fileCache = fileCache; _tileProvider = (WebTileProvider)tileSource.Provider; var spatialReferences = new SpatialReferences(); _dataSpatialReference = spatialReferences.GetSpatialReference(tileSource.Schema.Srs); //var fetcher = new FileFetcher<Image>(osmTileSource, fileCache); _display = display; if (!activeView.Extent.IsEmpty) { _tiles = GetTiles(activeView); currentLevel = _currentLevel; Logger.Debug("Number of tiles to draw: " + _tiles.Count); if (_tiles.ToList().Count > 0) { stepProgressor.MinRange = 0; stepProgressor.MaxRange = _tiles.ToList().Count; stepProgressor.Show(); var downloadFinished = new ManualResetEvent(false); // this is a hack, otherwise we get error message... // "WaitAll for multiple handles on a STA thread is not supported. (mscorlib)" // so lets start a thread first... var t = new Thread(DownloadTiles); t.Start(downloadFinished); // wait till finished downloadFinished.WaitOne(); // 3. Now draw all tiles... if (layerSpatialReference != null && _dataSpatialReference!=null) { _needReproject = (layerSpatialReference.FactoryCode != _dataSpatialReference.FactoryCode); } Logger.Debug("Need reproject tile: " + _needReproject.ToString()); foreach (var tile in _tiles) { stepProgressor.Step(); if (tile != null) { var name = _fileCache.GetFileName(tile.Index); if (!File.Exists(name)) continue; DrawRaster(name); } } stepProgressor.Hide(); } else { Logger.Debug("No tiles to retrieve or draw"); } Logger.Debug("End drawing tiles: " + _tiles.ToList().Count); } }
/// <summary> /// Ejecuta el modelo de amenazas de incendios /// </summary> /// <param name="sTablaPrecipPromedio">Tabla Precipitacion Promedio</param> /// <param name="sConsultaTablaPrecipPromedio">SQL para la table precipitacion promedio</param> /// <param name="sPrefijo">Prefijo para los nombres de las capas</param> /// <param name="sTablaTempPromedio">Nombre de la tabla temporal de promedios</param> /// <param name="sConsultaTablaTempPromedio">SQL para la tabla temporal de promedios</param> /// <param name="bUsarSatelite">Indica si se han de utilizar las imagenes de satelita</param> /// <param name="bMostrarIntermedios">Indica si se mostraran los resultados intermedios en el mapa activo</param> private void GenerarModelo(string sTablaPrecipPromedio, string sConsultaTablaPrecipPromedio, string sPrefijo, string sTablaTempPromedio, string sConsultaTablaTempPromedio, bool bUsarSatelite, bool bMostrarIntermedios, String[] sRastersPrecipitacion) { String sPath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase); String tempDir = ""; sPath = sPath.Replace("file:\\", ""); SIGPIParametros parametros = new SIGPIParametros(); try { XmlSerializer serializer = new XmlSerializer(typeof(SIGPIParametros)); System.IO.StreamReader r = new System.IO.StreamReader(sPath + "\\parameters\\parametros.xml"); parametros = (SIGPIParametros)serializer.Deserialize(r); r.Close(); serializer = null; r = null; } catch (Exception ex) { MessageBox.Show(ex.Message, "SIGPI 2013"); return; } SIGPIProcesamiento procesamiento = new SIGPIProcesamiento(parametros); SIGPICls sigpi = new SIGPICls(); SIGPIDao sigpiDao = new SIGPIDao(); sigpiDao.ConnectLocalDB(parametros.RutaBD); sigpiDao.UltimaFechaIncorporacion(sigpi); sigpi.Parametros = parametros; OleDbCommand command = sigpiDao.LocalDBConnection.CreateCommand(); OleDbParameter param = command.CreateParameter(); OleDbParameter param1 = command.CreateParameter(); param.ParameterName = "fecProce"; param.Value = sigpi.FechaProcesamiento; command.CommandText = "UPDATE FECHAS_PROCESO SET FEC_PROCE = @fecProce"; command.Parameters.Add(param); string sSQL = ""; // "UPDATE FECHAS_PROCESO SET FEC_PROCE = #" + sigpi.FechaProcesamiento.ToString("MM/dd/yyyy") + "#"; try { sigpiDao.EjecutarSentenciaSinQuery(command); } catch (Exception ex) { MessageBox.Show("No se pudo actualizar la fecha de incorporacion.\n" + ex.Message); } IProgressDialogFactory pProDiaFac = new ProgressDialogFactoryClass(); IStepProgressor pStepPro = pProDiaFac.Create(null, 0); pStepPro.MinRange = 1; pStepPro.MaxRange = 5; pStepPro.StepValue = 1; IProgressDialog2 pProDia = (IProgressDialog2)pStepPro; pProDia.Animation = esriProgressAnimationTypes.esriProgressGlobe; pProDia.Title = "Generar Modelo Amenazas"; pProDia.ShowDialog(); pStepPro.Step(); pStepPro.Message = "Generando Grids Meteorologicos..."; IFeatureClass pFeatureClass; IWorkspaceFactory pShpWorkspaceFactory = new ShapefileWorkspaceFactoryClass(); IWorkspaceFactory pFileGDBWorkspaceFactory = new FileGDBWorkspaceFactoryClass(); string sFormatTmp = "gdb_" + sigpi.FechaProcesamiento.ToString("yyyyMMdd") + "_" + DateTime.Now.ToString("HHmmss"); tempDir = sigpi.Parametros.TempDir; if (tempDir == null || tempDir.Trim().Equals("")) { tempDir = System.IO.Path.GetTempPath(); } string sRutaFileGDB = System.IO.Path.GetTempPath() + sFormatTmp + ".gdb"; if (System.IO.Directory.Exists(sRutaFileGDB)) { try { System.IO.Directory.Delete(sRutaFileGDB); } catch (Exception ex) { MessageBox.Show("No se pudo borrar la File Geodatabase Temporal: " + sRutaFileGDB + " Intente Borrarla Manualmente. " + ex.Message); return; } } Geoprocessor gp = new Geoprocessor(); IWorkspaceName pWSName; string sCapaResultado = "Amenaza_" + sigpi.FechaProcesamiento.ToString("yyyy_MM_dd"); string sRutaGdbResultados = parametros.RutaSIGPI + parametros.Resultado + "\\" + sigpi.FechaProcesamiento.Year.ToString() + "-" + sigpi.FechaProcesamiento.ToString("MM") + "-Modelos.gdb"; if (System.IO.Directory.Exists(sRutaGdbResultados)) { GPUtilitiesClass gpUtilClass = new GPUtilitiesClass(); try { Delete del = new Delete(); del.in_data = sRutaGdbResultados + "\\" + sCapaResultado; gp.Execute(del, null); } catch (Exception) { } } else { try { pWSName = pFileGDBWorkspaceFactory.Create(parametros.RutaSIGPI + parametros.Resultado + "\\", sigpi.FechaProcesamiento.Year.ToString() + "-" + sigpi.FechaProcesamiento.ToString("MM") + "-Modelos.gdb", null, 0); } catch (Exception ex) { MessageBox.Show("No se pudo crear la Geodatabase de resultados: \n" + sRutaGdbResultados); pStepPro.Hide(); } } pWSName = pFileGDBWorkspaceFactory.Create(System.IO.Path.GetTempPath(), sFormatTmp, null, 0); ESRI.ArcGIS.esriSystem.IName name = (ESRI.ArcGIS.esriSystem.IName)pWSName; IFeatureWorkspace pWorkspaceTemp; try { pWorkspaceTemp = (IFeatureWorkspace)name.Open(); } catch (Exception ex) { MessageBox.Show(ex.Message); return; } IWorkspaceFactory pWF = new AccessWorkspaceFactoryClass(); IFeatureWorkspace pWSMask = (IFeatureWorkspace)pWF.OpenFromFile(parametros.RutaGBD, 0); IGeoDataset pFCMask = (IGeoDataset)pWSMask.OpenFeatureClass(parametros.Mascara); ISpatialReference pSpaRef = pFCMask.SpatialReference; IEnvelope pEnv = pFCMask.Extent; string sNombreTabla = "TMPPR_"; DateTime fechaProcesamiento = sigpi.FechaProcesamiento; fechaProcesamiento = fechaProcesamiento.Date; for (int i = 0; i < 10; i++) { try { sigpiDao.EjecutarSentenciaSinQuery("DROP TABLE " + sNombreTabla + i.ToString()); } catch (Exception ex) { System.Console.WriteLine(ex.Message); } // "IIf([LECTUS_PRECI]![LECTURA]<=2,5,IIf([LECTUS_PRECI]![LECTURA]<=8 And [LECTUS_PRECI]![LECTURA]>2,4,IIf([LECTUS_PRECI]![LECTURA]<=14 And [LECTUS_PRECI]![LECTURA]>8,3,IIf([LECTUS_PRECI]![LECTURA]<=24 And [LECTUS_PRECI]![LECTURA]>14,2,IIf([LECTUS_PRECI]![LECTURA]>24,1,0))))) AS LECTURAS " + //sSQL = "SELECT CODIGO, FECHA, X, Y, LECTURA AS RASTERVALU " + // "INTO " + sNombreTabla + i.ToString() + " " + // "FROM LECTUS_PRECI " + // "WHERE (((FECHA)=#" + sigpi.FechaProcesamiento.AddDays(-i).ToString("MM/dd/yyyy") + "#))"; command = sigpiDao.LocalDBConnection.CreateCommand(); command.CommandText = "SELECT CODIGO, FECHA, X, Y, LECTURA AS RASTERVALU " + "INTO " + sNombreTabla + i.ToString() + " " + "FROM LECTUS_PRECI " + "WHERE (((FECHA) >=@fecha) and ((FECHA) <@fecha1))"; param = command.CreateParameter(); param.ParameterName = "fecha"; param.Value = sigpi.FechaProcesamiento.AddDays(-i); command.Parameters.Add(param); param1 = command.CreateParameter(); param1.ParameterName = "fecha1"; param1.Value = sigpi.FechaProcesamiento.AddDays(-i + 1); command.Parameters.Add(param1); try { sigpiDao.EjecutarSentenciaSinQuery(command); } catch (Exception ex) { MessageBox.Show("Error generando las tablas temporales de precipitaciones. Descripcion: \n" + ex.Message); //pProDia.HideDialog(); return; } } try { sigpiDao.EjecutarSentenciaSinQuery("DROP TABLE TEMPERATURA_PROMEDIO"); } catch (Exception ex) { } //"IIf(Avg(LECTUS_TEMPE.LECTURA)<=6,1,IIf(Avg(LECTUS_TEMPE.LECTURA) <=12 And Avg(LECTUS_TEMPE.LECTURA)>6,2," + //"IIf(Avg(LECTUS_TEMPE.LECTURA)<=18 And Avg(LECTUS_TEMPE.LECTURA)>12,3,IIf(Avg(LECTUS_TEMPE.LECTURA)<=24 And " + //"Avg(LECTUS_TEMPE.LECTURA)>12,4,IIf(Avg(LECTUS_TEMPE.LECTURA)>24,5,0))))) AS LECTURAS, " + //sSQL = "SELECT CODIGO, Max(LECTUS_TEMPE.FECHA) AS FECHA, 10 AS Num_Dias, X, Y, AVG(LECTURA) AS RASTERVALU " + // "INTO TEMPERATURA_PROMEDIO " + // "FROM LECTUS_TEMPE " + // "WHERE (((FECHA)>=#" + sigpi.FechaProcesamiento.AddDays(-10).ToString("MM/dd/yyyy") + "# " + // "And (FECHA)<=#" + sigpi.FechaProcesamiento.ToString("MM/dd/yyyy") + "#)) " + // "GROUP BY CODIGO, X, Y"; command = sigpiDao.LocalDBConnection.CreateCommand(); command.CommandText = "SELECT CODIGO, Max(LECTUS_TEMPE.FECHA) AS FECHA, 10 AS Num_Dias, X, Y, AVG(LECTURA) AS RASTERVALU " + "INTO TEMPERATURA_PROMEDIO " + "FROM LECTUS_TEMPE " + "WHERE (((FECHA)>= @fecha1 " + "And (FECHA)<= @fecha)) " + "GROUP BY CODIGO, X, Y"; param = command.CreateParameter(); param.ParameterName = "fecha"; param.Value = sigpi.FechaProcesamiento; param1 = command.CreateParameter(); param1.ParameterName = "fecha1"; param1.Value = sigpi.FechaProcesamiento.AddDays(-10); command.Parameters.Add(param1); command.Parameters.Add(param); try { sigpiDao.EjecutarSentenciaSinQuery(command); } catch (Exception ex) { MessageBox.Show("Error Generando Tabla: TEMPERATURA_PROMEDIO " + ex.Message); pProDia.HideDialog(); return; } string sExpression = ""; string sOutGrid; double dPeso = 0; string sAmenazaXPrecipitacion = sRutaFileGDB + "\\amenaza_x_precipitacion"; string sTablaTemperaturaPromedio = "TEMPERATURA_PROMEDIO"; string sFCTempPromedio = "TEMP_PROMEDIO"; string sPrefijoIDW = "idw"; string sAmenazaXTemperatura = sRutaFileGDB + "\\" + "amenaza_x_temperatura"; string sAmenazasParciales = parametros.RutaGBD + "\\" + "amenazas_parciales_2"; string sAmenazaBruta = sRutaFileGDB + "\\amenaza_incendio_bruta"; string sAmenazaFinal = sRutaFileGDB + "\\amenaza_incendio_final"; string sTablaReclassIncendios = parametros.TablaReclasificacionIncendios; //"tbl_reclass_amenaza_incendios"; string sTablaReclassTemp = parametros.TablaReclasificacionTemperatura; //"tbl_reclass_temperatura"; string sTablaReclassPrecip = parametros.TablaReclasificacionPrecipitacion; //"tbl_reclass_precipitacion"; string sAmenazaXTemperaturaCombinada = sRutaFileGDB + "\\" + "amenaza_x_temperatura_combinada"; string sEstVirtualesPrecipitacion = sRutaFileGDB + "\\" + "estaciones_virtuales_precipitacion"; string sAmenazaXPrecipitacionCombinada = sRutaFileGDB + "\\" + "amenaza_x_precipitacion_combinada"; string sAmenazaFinalBrutaNVI = sRutaFileGDB + "\\" + "amenaza_incend_raw_nvi"; string sNVITempReclass = sRutaFileGDB + "\\" + "nvi_reclass_temp"; string sFromField = "FROM_"; string sToField = "TO_"; string sOutField = "OUT"; string sNoData = "NODATA"; string sFieldLecturas = "RASTERVALU"; //LECTURAS"; string sTipoEstadistico = parametros.TipoEstadistico; //"MAXIMUM"; string sAmenazaXPrecipReclass = sAmenazaXPrecipitacion + "_reclass"; string sAmenazaXTempReclass = sAmenazaXTemperatura + "_reclass"; string nvi = parametros.RutaSIGPI + "NVI" + "\\" + "tmpMosaic.500m_16_days_NDVI_GEO.tif"; double dPesoPrecipitacion = parametros.PesoPrecipitacion; //0.29; double dPesoTemperatura = parametros.PesoTemperatura; //0.24; double dPesoAmenazasParciales = parametros.PesoAmenazasParciales; //0.47; IDataset pDS; IDatasetName pDSName; IDatasetName pDSName2 = new FeatureClassNameClass(); IExportOperation pExportOp = new ExportOperationClass(); string sEstacionesVirtuales = sRutaFileGDB + "\\" + "EstacionesVirtuales.shp"; ExtractValuesToPoints extractValPoint = new ExtractValuesToPoints(); extractValPoint.in_point_features = sEstacionesVirtuales; extractValPoint.interpolate_values = "NONE"; extractValPoint.add_attributes = "VALUE_ONLY"; //'0.037037037; // 1" = 1/3600 double dCellSize = parametros.TamanoCelda / (3600 * 30); double[] iPesos = parametros.Pesos; //{ 30, 20, 10, 9, 8, 7, 6, 5, 4, 3 }; double iTotalPesos = 0; //102; foreach (double dP in iPesos) { iTotalPesos += dP; } gp.AddOutputsToMap = bMostrarIntermedios; gp.SetEnvironmentValue("Mask", parametros.RutaGBD + "\\" + parametros.Mascara); gp.SetEnvironmentValue("Extent", pEnv.XMin.ToString() + " " + pEnv.YMin.ToString() + " " + pEnv.XMax.ToString() + " " + pEnv.YMax.ToString()); ESRI.ArcGIS.SpatialAnalystTools.Idw idw = new Idw(); idw.z_field = sFieldLecturas; idw.cell_size = dCellSize; for (int i = 0; i < 10; i++) { pFeatureClass = procesamiento.FCPrecipitacion(sNombreTabla + i.ToString(), pSpaRef); pDS = (IDataset)pFeatureClass; pDSName = (IDatasetName)pDS.FullName; pDSName2.Name = sNombreTabla + i.ToString(); pDSName2.WorkspaceName = pWSName; try { pExportOp.ExportFeatureClass(pDSName, null, null, null, (IFeatureClassName)pDSName2, 0); } catch (Exception ex) { MessageBox.Show(ex.Message); pProDia.HideDialog(); return; } if (bUsarSatelite) { //Geoprocessor gp1 = new Geoprocessor(); //extractValPoint.in_raster = sRastersPrecipitacion[i]; // txtRutaPrecipitacion.Text; //extractValPoint.out_point_features = sEstVirtualesPrecipitacion + i.ToString(); //try //{ // gp1.Execute(extractValPoint, null); //} //catch (Exception ex) //{ // MessageBox.Show(ex.Message); //} //Merge merge = new Merge(); //string sInputMerge = sRutaFileGDB + "\\" + sNombreTabla + i.ToString() + ";" + sEstVirtualesPrecipitacion + i.ToString(); //merge.inputs = sInputMerge; ////"[" + sRutaFileGDB + "\\" + sNombreTabla + i.ToString() + ";" + sEstVirtualesPrecipitacion + i.ToString() + "]" ; //merge.output = sRutaFileGDB + "\\" + "est_precip_temporal" + i.ToString(); //try //{ // gp.Execute(merge, null); //} //catch (Exception ex) //{ // MessageBox.Show(ex.Message); //} //idw.in_point_features = sRutaFileGDB + "\\" + "est_precip_temporal" + i.ToString(); idw.in_point_features = sRutaFileGDB + "\\" + sNombreTabla + i.ToString(); } else { idw.in_point_features = sRutaFileGDB + "\\" + sNombreTabla + i.ToString(); } sOutGrid = sRutaFileGDB + "\\" + sPrefijoIDW + "_" + sNombreTabla + i.ToString(); idw.out_raster = sOutGrid; try { gp.Execute(idw, null); } catch (Exception ex) { MessageBox.Show(ex.Message); } dPeso = iPesos[i] / iTotalPesos; sExpression += "( Raster(r'" + sOutGrid + "') * " + dPeso.ToString().Replace(",", ".") + ")"; if (i < 9) { sExpression += " + "; } } pStepPro.Step(); ////for (int i = 0; i < 10; i++) ////{ //// //pStepPro.Message = "Generando Modelo Precipitacion: " + i.ToString(); //// sOutGrid = sRutaFileGDB + "\\" + sPrefijoIDW + "_" + sNombreTabla + i.ToString(); //// idw.in_point_features = sRutaFileGDB + "\\" + sNombreTabla + i.ToString(); //// idw.out_raster = sOutGrid; //// gp.Execute(idw, null); //// dPeso = iPesos[i] / iTotalPesos; //// sExpression += "(" + sOutGrid + " * " + dPeso.ToString() + ")"; //// if (i < 9) //// sExpression += " + "; ////} //gp.AddMessage("Expresion: " + sExpression); //SingleOutputMapAlgebra mapAlgebra = new SingleOutputMapAlgebra(); ESRI.ArcGIS.SpatialAnalystTools.RasterCalculator mapAlgebra = new RasterCalculator(); //mapAlgebra.expression_string = sExpression; // mapAlgebra.out_raster = sAmenazaXPrecipitacion; mapAlgebra.expression = sExpression; mapAlgebra.output_raster = sAmenazaXPrecipitacion; pStepPro.Message = "Generando Amenaza Precipitacion..."; try { gp.Execute(mapAlgebra, null); } catch (Exception ex) { MessageBox.Show("Error Generando Amenaza x Precipitacion. " + ex.Message); pProDia.HideDialog(); return; } //if (bUsarSatelite) // Para la combinacion de la precipitacion x estaciones y satelite //{ // //CellStatistics cellStatisticsP = new CellStatistics(); // //cellStatisticsP.in_rasters_or_constants = sAmenazaXPrecipitacion + ";" + txtRutaPrecipitacion.Text; // //cellStatisticsP.out_raster = sAmenazaXPrecipitacionCombinada; // //cellStatisticsP.statistics_type = sTipoEstadistico; // try // { // gp.Execute(extractValPoint, null); // //sAmenazaXPrecipitacion = sAmenazaXPrecipitacionCombinada; // } // catch (Exception ex) // { // MessageBox.Show("Error generando estaciones virtuales con precipitacion." + ex.Message); // return; // } // Merge merge = new Merge(); // merge.inputs = //} DateTime date = sigpi.FechaProcesamiento; string sMonth = date.ToString("MM"); pStepPro.Step(); pStepPro.Message = "Generando Amenaza x Temperatura"; pFeatureClass = procesamiento.FCPrecipitacion(sTablaTemperaturaPromedio, pSpaRef); pDS = (IDataset)pFeatureClass; pDSName = (IDatasetName)pDS.FullName; pDSName2.Name = sFCTempPromedio; pDSName2.WorkspaceName = pWSName; try { pExportOp.ExportFeatureClass(pDSName, null, null, null, (IFeatureClassName)pDSName2, 0); } catch (Exception ex) { throw new Exception(ex.Message); } idw.in_point_features = sRutaFileGDB + "\\" + sFCTempPromedio; idw.out_raster = sAmenazaXTemperatura; try { gp.Execute(idw, null); } catch (Exception ex) { Console.WriteLine(ex.Message); } //if (bUsarSatelite) //{ // Geoprocessor gp1 = new Geoprocessor(); // Con pContmp = new Con(); // pContmp.in_conditional_raster = txtRutaTemperatura.Text; // pContmp.in_true_raster_or_constant = txtRutaTemperatura.Text; // pContmp.in_false_raster_or_constant = -99; // string sRasterTTemp = sAmenazaXTemperaturaCombinada + "_ajs"; // pContmp.out_raster = sRasterTTemp; // pContmp.where_clause = "VALUE < 55"; // try // { // gp1.Execute(pContmp, null); // } // catch (Exception) // { // sRasterTTemp = txtRutaTemperatura.Text; ; // } // gp1 = null; // CellStatistics cellStatistics = new CellStatistics(); // cellStatistics.in_rasters_or_constants = sAmenazaXTemperatura + ";" + sRasterTTemp; // cellStatistics.out_raster = sAmenazaXTemperaturaCombinada; // cellStatistics.statistics_type = sTipoEstadistico; // try // { // gp.Execute(cellStatistics, null); // sAmenazaXTemperatura = sAmenazaXTemperaturaCombinada; // } // catch (Exception) // { // } //} ReclassByTable rbt = new ReclassByTable(); rbt.in_raster = sAmenazaXPrecipitacion; rbt.in_remap_table = sTablaReclassPrecip; // parametros.RutaGBD + "\\" + sTablaReclassPrecip; rbt.from_value_field = sFromField; rbt.to_value_field = sToField; rbt.output_value_field = sOutField; rbt.missing_values = sNoData; rbt.out_raster = sAmenazaXPrecipReclass; //pStepPro.Message = "Generando Amenaza X Precipitacion Reclasificada"; try { gp.Execute(rbt, null); } catch (Exception ex) { MessageBox.Show(ex.Message); pProDia.HideDialog(); return; } rbt.in_raster = sAmenazaXTemperatura; rbt.in_remap_table = sTablaReclassTemp; // parametros.RutaGBD + "\\" + sTablaReclassTemp; rbt.out_raster = sAmenazaXTempReclass; //pStepPro.Message = "Generando Amenaza X Temperatura Reclasificada"; try { gp.Execute(rbt, null); } catch (Exception ex) { MessageBox.Show(ex.Message); pProDia.HideDialog(); return; } sExpression = "( Raster(r'" + sAmenazaXPrecipReclass + "') * " + dPesoPrecipitacion.ToString().Replace(",", ".") + ") + " + "( Raster(r'" + sAmenazaXTempReclass + "') * " + dPesoTemperatura.ToString().Replace(",", ".") + ") + " + "( Raster(r'" + sAmenazasParciales + "') * " + dPesoAmenazasParciales.ToString().Replace(",", ".") + ")"; //mapAlgebra.expression_string = sExpression; //mapAlgebra.out_raster = sAmenazaBruta; sExpression = sExpression.Replace("\\\\", "/").Replace("\\", "/"); mapAlgebra.expression = sExpression; mapAlgebra.output_raster = sAmenazaBruta; pStepPro.Message = "Generando Amenaza Final Bruta"; try { gp.Execute(mapAlgebra, null); } catch (Exception ex) { MessageBox.Show(ex.Message); } //if (txtRutaNVI.Text.Trim() != "") //{ Geoprocessor gp2 = new Geoprocessor(); mapAlgebra = new RasterCalculator(); sExpression = "Con (Raster(r'" + nvi + "') < 0.75, Raster(r'" + sAmenazaBruta + "'), Raster(r'" + sAmenazaBruta + "') -1)"; sExpression = sExpression.Replace("\\\\", "/").Replace("\\", "/"); mapAlgebra.expression = sExpression; mapAlgebra.output_raster = sAmenazaFinalBrutaNVI; try { gp2.Execute(mapAlgebra, null); } catch (Exception ex) { MessageBox.Show(ex.Message); } //} rbt.in_raster = sAmenazaFinalBrutaNVI; // sAmenazaBruta; rbt.in_remap_table = sTablaReclassIncendios; // parametros.RutaGBD + "\\" + sTablaReclassIncendios; rbt.from_value_field = sFromField; rbt.to_value_field = sToField; rbt.output_value_field = sOutField; rbt.missing_values = sNoData; rbt.out_raster = sAmenazaFinal; pStepPro.Message = "Generando Amenaza Final Reclasificada"; gp.AddOutputsToMap = true; try { gp.Execute(rbt, null); } catch (Exception ex) { MessageBox.Show(ex.Message); } Copy copy = new Copy(); copy.in_data = sAmenazaFinal; copy.out_data = sRutaGdbResultados + "\\" + sCapaResultado; try { gp.Execute(copy, null); } catch (Exception ex) { MessageBox.Show("Error Copiando el resultado. \n " + ex.Message); } MessageBox.Show("Algoritmo completo ejecutado: " + sRutaGdbResultados + "\\" + sCapaResultado); if (m_pApp != null) { IRasterLayer pRLayer = new RasterLayerClass(); try { IWorkspaceFactory pWF2 = new FileGDBWorkspaceFactoryClass(); IRasterWorkspaceEx pRW = (IRasterWorkspaceEx)pWF2.OpenFromFile(sRutaGdbResultados, 0); IRasterDataset pRDataset = pRW.OpenRasterDataset(sCapaResultado); pRLayer.CreateFromDataset(pRDataset); pRLayer.Name = sCapaResultado; IMxDocument pMxDoc = m_pApp.Document as IMxDocument; IMap pMap = pMxDoc.FocusMap; AsignarSimbologiaProbabilidad(pRLayer); pMap.AddLayer(pRLayer); if (pMap.LayerCount > 0) { pMap.MoveLayer(pRLayer, pMap.LayerCount - 1); } pMxDoc.UpdateContents(); pMxDoc.ActiveView.Refresh(); } catch (Exception ex) { MessageBox.Show(ex.Message, "Error cargando Capa!!!"); } } pProDia.HideDialog(); }
private void Cleanup(IMouseCursor MouseCursor, IFIDSet PlansFIDSet, ITable pTable, ITable PlansTable, IWorkspace Workspace, IProgressDialog2 pProgressorDialog) { if (pProgressorDialog != null) { pProgressorDialog.HideDialog(); } if (MouseCursor != null) { MouseCursor.SetCursor(0); } if (m_pStepProgressor != null) { m_pStepProgressor.Hide(); } m_pStepProgressor = null; try { Marshal.ReleaseComObject(PlansFIDSet); //garbage collection } catch { } try { Marshal.ReleaseComObject(m_pProgressorDialogFact); //garbage collection } catch { } try { Marshal.ReleaseComObject(m_pTrackCancel); //garbage collection } catch { } if (PlansTable != null) { Marshal.ReleaseComObject(PlansTable); } if (m_pCadaFab != null) { Marshal.ReleaseComObject(m_pCadaFab); } if (pTable != null) { Marshal.ReleaseComObject(pTable); } if (Workspace != null) { Marshal.ReleaseComObject(Workspace); } if (m_pStartTime != null) { Marshal.ReleaseComObject(m_pStartTime); } if (m_pEndTime != null) { Marshal.ReleaseComObject(m_pEndTime); } }
private void Cleanup(IMouseCursor MouseCursor, IFIDSet PlansFIDSet, ITable pTable, ITable PlansTable, IWorkspace Workspace, IProgressDialog2 pProgressorDialog, bool CleanFabricVar) { if (pProgressorDialog != null) { pProgressorDialog.HideDialog(); } if (MouseCursor != null) { MouseCursor.SetCursor(0); } if (m_pStepProgressor != null) { m_pStepProgressor.Hide(); } m_pStepProgressor = null; if (PlansFIDSet != null) { do { }while (Marshal.ReleaseComObject(PlansFIDSet) > 0); } if (m_pProgressorDialogFact != null) { do { }while (Marshal.ReleaseComObject(m_pProgressorDialogFact) > 0); } if (m_pTrackCancel != null) { do { }while (Marshal.ReleaseComObject(m_pTrackCancel) > 0); } if (PlansTable != null) { do { }while (Marshal.ReleaseComObject(PlansTable) > 0); } if (m_pCadaFab != null && CleanFabricVar) { do { }while (Marshal.ReleaseComObject(m_pCadaFab) > 0); } if (pTable != null) { do { }while (Marshal.ReleaseComObject(pTable) > 0); } if (Workspace != null) { do { }while (Marshal.ReleaseComObject(Workspace) > 0); } }
protected override void OnClick() { try { IGxSelection gxSelection = this.pGxApp.Selection; if (gxSelection.Count < 1) { return; } // Inizializzo le variabili per la progress bar... ITrackCancel trkCancel = null; IProgressDialogFactory prgFact = new ProgressDialogFactoryClass(); IStepProgressor stepProgressor = null; IProgressDialog2 progressDialog = null; int intNumberFcConverted = 0; int cont = gxSelection.Count; IEnumGxObject enumGxObject = gxSelection.SelectedObjects; stepProgressor = prgFact.Create(trkCancel, 0); progressDialog = stepProgressor as IProgressDialog2; progressDialog.Description = "Removing extensions..."; progressDialog.Title = "Removing extensions..."; progressDialog.Animation = esriProgressAnimationTypes.esriProgressSpiral; progressDialog.ShowDialog(); stepProgressor.MinRange = 0; stepProgressor.MaxRange = cont; stepProgressor.StepValue = 1; stepProgressor.Show(); IGxObject pGxObject = enumGxObject.Next(); while (pGxObject != null) { if (!(pGxObject is IGxDataset)) { return; } IGxDataset pGxDataset = pGxObject as IGxDataset; if (pGxDataset == null) { return; } //if (((pGxObject as IGxDataset).Type) != esriDatasetType.esriDTFeatureClass) //{ // return; //} this.engine(pGxDataset, pGxObject, ref intNumberFcConverted); pGxObject = enumGxObject.Next(); stepProgressor.Step(); } stepProgressor.Message = "End"; stepProgressor.Hide(); progressDialog.HideDialog(); MessageBox.Show($@"Extension removed for {intNumberFcConverted} objects!", "Attention", MessageBoxButtons.OK, MessageBoxIcon.Information); } catch (Exception ex) { MessageBox.Show("Error: " + ex.Message.ToString()); } }