private static ITable CreateTable(IWorkspace2 workspace, string tableName, IFields fields)
{
UID uid = new UIDClass {Value = "esriGeoDatabase.Object"};
if (workspace == null) return null;
IFeatureWorkspace featWorkspace = (IFeatureWorkspace) workspace;
if (workspace.NameExists[esriDatasetType.esriDTTable, tableName])
{
using (ComReleaser releaser = new ComReleaser())
{
ITable table = featWorkspace.OpenTable(tableName);
releaser.ManageLifetime(table);
((IDataset) table).Delete();
}
}
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = workspace as IWorkspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
return featWorkspace.CreateTable(tableName, validatedFields, uid, null, string.Empty);
}
/// <summary>
/// Returns the values in case the field is numeric, otherwise the IEnumerable is empty.
/// DBNull values are skipped.
/// </summary>
/// <returns></returns>
public IEnumerable <double> GetFieldData()
{
if (!IsNumeric && !IsOID)
{
return(Enumerable.Empty <double>());
}
IList <double> data = new List <double>();
using (var comReleaser = new ComReleaser())
{
var featureCursor = Feature.FeatureClass.Search(null, true);
comReleaser.ManageLifetime(featureCursor);
var fieldIndex = Feature.FeatureClass.FindField(FieldName);
IFeature currentFeature;
while ((currentFeature = featureCursor.NextFeature()) != null)
{
if (currentFeature.Value[fieldIndex] is DBNull)
{
continue;
}
var t = (Convert.ToDouble(currentFeature.Value[fieldIndex]));
data.Add(t);
}
}
return(data.AsEnumerable());
}
private IElement method_1(object object_1)
{
if (object_1 is DBNull)
{
return(null);
}
IMemoryBlobStream o = object_1 as IMemoryBlobStream;
IPropertySet set = new PropertySetClass();
IObjectStream pstm = new ObjectStreamClass
{
Stream = o
};
IPersistStream stream3 = set as IPersistStream;
stream3.Load(pstm);
IElement property = null;
try
{
property = set.GetProperty("Element") as IElement;
}
catch (Exception)
{
}
ComReleaser.ReleaseCOMObject(stream3);
ComReleaser.ReleaseCOMObject(set);
ComReleaser.ReleaseCOMObject(o);
set = null;
return(property);
}
public DataTable ITable2Tatatable(ITable itable_1, string string_0)
{
DataTable dataTable0;
if (itable_1 != null)
{
this.dataTable_0.Rows.Clear();
this.dataTable_0.Columns.Clear();
this.method_0(itable_1.Fields, this.dataTable_0);
string str = "";
if (itable_1 is IFeatureClass)
{
str = this.method_1(itable_1 as IFeatureClass);
}
IQueryFilter queryFilterClass = new QueryFilter()
{
WhereClause = string_0
};
ICursor cursor = null;
cursor = (string_0 != "" ? itable_1.Search(queryFilterClass, false) : itable_1.Search(null, false));
this.itable_0 = itable_1;
this.method_2(true, this.dataTable_0, cursor, str);
ComReleaser.ReleaseCOMObject(cursor);
dataTable0 = this.dataTable_0;
}
else
{
dataTable0 = null;
}
return(dataTable0);
}
private void CatoTemplateApplySelect_Load(object sender, EventArgs e)
{
CartoTemplateTableStruct struct2 = new CartoTemplateTableStruct();
ITable table = AppConfigInfo.OpenTable(struct2.TableName);
if (table != null)
{
ICursor o = table.Search(null, false);
IRow row = o.NextRow();
string[] items = new string[2];
while (row != null)
{
CartoTemplateData data = new CartoTemplateData(row);
items[0] = data.Name;
items[1] = data.Description;
ListViewItem item = new ListViewItem(items)
{
Tag = data
};
this.listView1.Items.Add(item);
row = o.NextRow();
}
ComReleaser.ReleaseCOMObject(o);
o = null;
}
}
//双击选中的属性表
private void gviewSelect_DoubleClick(object sender, EventArgs e)
{
GridView gridControl = sender as GridView;
if (gridControl == null || featureLayer.FeatureClass == null)
{
return;
}
try
{
DataRow dataRow = gridControl.GetFocusedDataRow();
int oid = Convert.ToInt32(dataRow[featureLayer.FeatureClass.OIDFieldName]);
IFeature pSelFeature = featureLayer.FeatureClass.GetFeature(oid);
if (pSelFeature == null)
{
return;
}
using (ComReleaser pComReleaser = new ComReleaser())
{
pComReleaser.ManageLifetime(pSelFeature);
IMap pMap = BindingMapControl.Map;
IGeometry pGeometry = pSelFeature.ShapeCopy;
if (!IsEqualSpatialReference(pGeometry.SpatialReference, pMap.SpatialReference))
{
pGeometry.Project(pMap.SpatialReference);
}
Flash(BindingMapControl, pGeometry, true);
}
}
catch (Exception ep)
{
}
}
//右键菜单——当前页全选
private void barButtonItem2_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
try
{
DataTable showingDataTable = gridAllAttribute.DataSource as DataTable;
List <int> oidList = new List <int>();
foreach (DataRow dataRow in showingDataTable.Rows)
{
oidList.Add(Convert.ToInt32(dataRow[oidFieldName]));
}
using (ComReleaser comReleaser = new ComReleaser())
{
string whereClause = "";
IQueryFilter pQueryFilter = new QueryFilterClass();
comReleaser.ManageLifetime(pQueryFilter);
foreach (int i in oidList)
{
whereClause += "\"" + (featureLayer.FeatureClass as ITable).OIDFieldName + "\"=" + i + " OR ";
}
whereClause = whereClause.Substring(0, whereClause.Length - 3);
pQueryFilter.WhereClause = whereClause;
(featureLayer as IFeatureSelection).SelectFeatures(pQueryFilter, esriSelectionResultEnum.esriSelectionResultNew, false);
}
UpdateCtrlDataSource();
BindingMapControl.Refresh();
}
catch (Exception ex)
{
XtraMessageBox.Show("打开属性表错误");
}
}
public static void InsertLoadOnly(IFeatureClass featureCls, IList <IGeometry> geoList)
{
IFeatureClassLoad featureClsLoad = (IFeatureClassLoad)featureCls;
ISchemaLock schemaLock = (ISchemaLock)featureCls;
try
{
schemaLock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock);
featureClsLoad.LoadOnlyMode = true;
using (var comReleaser = new ComReleaser())
{
IFeatureBuffer featureBuffer = featureCls.CreateFeatureBuffer();
IFeatureCursor featureCursor = featureCls.Insert(true);
comReleaser.ManageLifetime(featureCursor);
featureBuffer.set_Value(featureBuffer.Fields.FindField("InstBy"), "B Pierce");
for (int ic = 0; ic < geoList.Count; ic++)
{
featureBuffer.Shape = geoList[0];
var featureOID = featureCursor.InsertFeature(featureBuffer);
if (ic % 10 == 0)
{
featureCursor.Flush();
}
}
featureCursor.Flush();
}
}
finally
{
featureClsLoad.LoadOnlyMode = false;
schemaLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock);
}
}
/// <summary>
///测试getFeature与getFeatures
/// </summary>
/// <param name="featureCls"></param>
/// <param name="oids"></param>
/// <param name="fieldIndex"></param>
public void SearchById(IFeatureClass featureCls, int[] oids, int fieldIndex)
{
foreach (var oid in oids)
{
var feature = featureCls.GetFeature(oid);
Console.WriteLine("oid:" + feature.get_Value(fieldIndex));
}
using (var comReleaser = new ComReleaser())
{
IFeatureCursor featureCursor = featureCls.GetFeatures(oids, true);;
IFeature feature = featureCursor.NextFeature();
while (feature != null)
{
Console.WriteLine("oid:" + feature.get_Value(fieldIndex));
feature = featureCursor.NextFeature();
}
}
using (var comReleaser = new ComReleaser())
{
IGeoDatabaseBridge geodatabaseBridge = new GeoDatabaseHelperClass();
IFeatureCursor featureCursor = geodatabaseBridge.GetFeatures(featureCls, oids, true);;
IFeature feature = featureCursor.NextFeature();
while (feature != null)
{
Console.WriteLine("oid:" + feature.get_Value(fieldIndex));
feature = featureCursor.NextFeature();
}
}
}
public static void SaveMxd()
{
IMapDocument oMapDoc = new MapDocumentClass();
oMapDoc.Open(AxMapControl.DocumentFilename);
if (oMapDoc.IsReadOnly[AxMapControl.DocumentFilename])
{
throw new InvalidOperationException("Can not save mxd. Is read only.");
}
AxMapControl.Update();
AxTocControl.Update();
oMapDoc.ReplaceContents((IMxdContents)AxMapControl.Map);
oMapDoc.Save(true, true);
oMapDoc.Close();
if (oMapDoc != null)
{
ComReleaser.ReleaseCOMObject(oMapDoc);
oMapDoc = null;
}
if (AxMapControl.Map != null)
{
ComReleaser.ReleaseCOMObject(AxMapControl.Map);
AxMapControl.Map = null;
}
GC.Collect();
GC.WaitForPendingFinalizers();
}
/// <summary>
/// An iterator-based implementation that encapsulates COM reference counting operation around ITfFnSearchCandidateProvider.GetSearchCandidates.
/// </summary>
public static IEnumerable<string> GetSearchCandidates(this ITfFnSearchCandidateProvider provider, string query, string applicationId = "")
{
using (var releaser = new ComReleaser())
{
var candidateList = releaser.ReceiveObject((out ITfCandidateList _) => provider.GetSearchCandidates(query, applicationId, out _));
if (candidateList == null)
{
yield break;
}
var numResults = default(uint);
if (!candidateList.GetCandidateNum(out numResults))
{
yield break;
}
var iter = Enumerable.Range(0, (int)numResults)
.Select(index => releaser.ReceiveObject((out ITfCandidateString _) => candidateList.GetCandidate((uint)index, out _)))
.Where(candidateString => candidateString != null)
.Select(candidateString =>
{
var resultString = string.Empty;
candidateString.GetString(out resultString);
return resultString;
})
.Where(str => !String.IsNullOrEmpty(str));
foreach (var candiate in iter)
{
yield return candiate;
}
}
}
public static void OpenTable(AxMapControl MapControl, ITableName pTName, DataTable dt = null)
{
try
{
MapControl.Map.ClearLayers();
MapControl.SpatialReference = null;
MapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewAll, null, null);
IName pName = pTName as IName;
ITable pFc = pName.Open() as ITable;
if (null != dt)
{
InitDataTable(pFc, dt);
ICursor pCursor = pFc.Search(null, false);
IRow pfea = pCursor.NextRow();
int j = 0;
while (pfea != null)
{
DataRow dataRow = dt.NewRow();
for (int i = 0; i < pfea.Fields.FieldCount; i++)
{
dataRow[i] = pfea.get_Value(i).ToString();
}
dt.Rows.Add(dataRow);
pfea = pCursor.NextRow();
j++;
}
ComReleaser.ReleaseCOMObject(pCursor);
}
}
catch { }
}
public IList <IFeatureClass> TravelWorkSpace4FeatureClass(IWorkspace workspace, string datasetName)
{
IList <IFeatureClass> result = new List <IFeatureClass>();
using (ComReleaser releaser = new ComReleaser())
{
//遍历要素集中的要素类
IEnumDataset dts = workspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
//releaser.ManageLifetime(dts);
IDataset dt = dts.Next();
//releaser.ManageLifetime(dt);
while (dt != null)
{
if (dt.Name.Equals(datasetName))
{
IEnumDataset fcs = dt.Subsets;
//releaser.ManageLifetime(fcs);
IDataset fc = fcs.Next();
//releaser.ManageLifetime(fc);
while (fc != null)
{
result.Add((fc as IFeatureClass));
fc = fcs.Next();
}
}
dt = dts.Next();
}
}
return(result);
}
/// <summary>
/// Iterates through all of those rows that have been resolved forcing a save (aka call store) with AUs enabled.
/// </summary>
protected void SaveAfterReconcile()
{
this.NotifyCallback(4, "Triggering AUs on the conflicts that are not resolved.");
// Toggle the AU framework.
using (new AutoUpdaterModeReverter(mmAutoUpdaterMode.mmAUMArcMap))
{
// Iterate through all of the rows that have been marked as 'None' and group by the table.
foreach (var rows in this.Rows.Where(o => o.Resolution == ConflictResolution.None).GroupBy(o => o.TableName))
{
Log.Info("Calling store on {0} row(s) within the {1} class.", rows.Count(), rows.Key);
using (ComReleaser cr = new ComReleaser())
{
IFeatureWorkspace currentWorkspace = (IFeatureWorkspace)this.Workspace;
ITable currentTable = currentWorkspace.OpenTable(rows.Key);
cr.ManageLifetime(currentTable);
foreach (var o in rows)
{
IRow currentRow = currentTable.Fetch(o.OID);
cr.ManageLifetime(currentRow);
// Call Store to Trigger the AUs.
this.SaveAndRebuild(currentRow);
}
}
}
}
}
/// <summary>
/// Queries the database and populates a <see cref="DataTable" /> with the resulting data from the specified SQL
/// statement.
/// </summary>
/// <param name="source">The process application reference.</param>
/// <param name="commandText">The command text.</param>
/// <returns>
/// Returns a <see cref="DataTable" /> representing the records returned by the command text.
/// </returns>
/// <exception cref="ArgumentNullException">commandText</exception>
public static DataTable ExecuteQuery(this IMMPxApplication source, string commandText)
{
if (source == null)
{
return(null);
}
if (commandText == null)
{
throw new ArgumentNullException("commandText");
}
var table = new DataTable();
table.Locale = CultureInfo.InvariantCulture;
using (var cr = new ComReleaser())
{
Recordset recordset = new RecordsetClass();
recordset.Open(commandText, source.Connection, CursorTypeEnum.adOpenDynamic, LockTypeEnum.adLockOptimistic, 0);
cr.ManageLifetime(recordset);
var adapter = new OleDbDataAdapter();
adapter.Fill(table, recordset);
recordset.Close();
}
return(table);
}
private IFeature FindFeature(IPoint ipoint_0)
{
IFeature feature = null;
double mapUnits = Common.ConvertPixelsToMapUnits((IActiveView)_context.FocusMap, this.double_0);
IEnvelope envelope = ipoint_0.Envelope;
envelope.Height = mapUnits;
envelope.Width = mapUnits;
envelope.CenterAt(ipoint_0);
ISpatialFilter spatialFilterClass = new SpatialFilter()
{
Geometry = envelope,
SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects
};
for (int i = 0; i < _context.FocusMap.LayerCount; i++)
{
IFeatureLayer layer = _context.FocusMap.Layer[i] as IFeatureLayer;
if (layer != null && layer.Visible && layer.FeatureClass != null &&
layer.FeatureClass.ShapeType == esriGeometryType.esriGeometryPolyline)
{
spatialFilterClass.GeometryField = layer.FeatureClass.ShapeFieldName;
IFeatureCursor featureCursor = layer.Search(spatialFilterClass, false);
this.GetProximityFeature(ipoint_0, featureCursor, ref feature);
ComReleaser.ReleaseCOMObject(featureCursor);
}
}
return(feature);
}
public List <IObjectTemplate> GetTemplatesByDataset(string datasetName)
{
List <IObjectTemplate> templates = new List <IObjectTemplate>();
ITable pTemplateTable = _workspace.OpenTable("YT_TEMPLATE_FEATURECLASS");
IQueryFilter pFilter1 = new QueryFilter();
pFilter1.WhereClause = "Dataset='" + datasetName + "'";
ICursor pCursor = pTemplateTable.Search(pFilter1, false);
int[] fieldIndexes = new int[6];
IRow pRow = pCursor.NextRow();
IQueryFilter pQueryFilter = new QueryFilter();
IObjectTemplate oneTemplate = null;
while (pRow != null)
{
oneTemplate = new ObjectTemplate(pRow);
templates.Add(oneTemplate);
pRow = pCursor.NextRow();
}
ComReleaser.ReleaseCOMObject(pFilter1);
ComReleaser.ReleaseCOMObject(pCursor);
ComReleaser.ReleaseCOMObject(pTemplateTable);
return(templates);
}
private IFeature FindEdgeFeature(string osmid)
{
List <IFeatureClass> fcEdges = OsmEdgeFeatureClasses;
foreach (IFeatureClass fcEdge in fcEdges)
{
IQueryFilter filter = new QueryFilterClass();
filter.SubFields = string.Join(",", new string[] { fcEdge.OIDFieldName, fcEdge.ShapeFieldName, "OSMID" });
filter.WhereClause = fcEdge.WhereClauseByExtensionVersion(osmid, "OSMID", OsmExtVersion);
using (ComReleaser cr = new ComReleaser())
{
IFeatureCursor cursor = fcEdge.Search(filter, false);
cr.ManageLifetime(cursor);
IFeature feature = cursor.NextFeature();
if (feature != null)
{
return(feature);
}
}
}
return(null);
}
private bool UpdateFieldValue(IField pField, object str)
{
IWorkspaceEdit workspace = (this.m_pFeatLayer.FeatureClass as IDataset).Workspace as IWorkspaceEdit;
bool flag = false;
try
{
ICursor cursor;
workspace.StartEditOperation();
int index = this.m_pFeatLayer.FeatureClass.Fields.FindField(pField.Name);
(this.m_pFeatLayer as IFeatureSelection).SelectionSet.Search(null, false, out cursor);
for (IRow row = cursor.NextRow(); row != null; row = cursor.NextRow())
{
row.set_Value(index, str);
row.Store();
}
ComReleaser.ReleaseCOMObject(cursor);
workspace.StopEditOperation();
try
{
}
catch
{
}
flag = true;
}
catch (Exception exception)
{
MessageBox.Show("输入数据格式错误");
CErrorLog.writeErrorLog(null, exception, "");
}
return(flag);
}
private static ITable CreateTable(IWorkspace2 workspace, string tableName, IFields fields)
{
UID uid = new UIDClass {
Value = "esriGeoDatabase.Object"
};
if (workspace == null)
{
return(null);
}
IFeatureWorkspace featWorkspace = (IFeatureWorkspace)workspace;
if (workspace.NameExists[esriDatasetType.esriDTTable, tableName])
{
using (ComReleaser releaser = new ComReleaser())
{
ITable table = featWorkspace.OpenTable(tableName);
releaser.ManageLifetime(table);
((IDataset)table).Delete();
}
}
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = workspace as IWorkspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
return(featWorkspace.CreateTable(tableName, validatedFields, uid, null, string.Empty));
}
public void Load()
{
if (this.mapTemplate != null)
{
this.mapTemplate.Clear();
}
IQueryFilter queryFilter = new QueryFilterClass
{
WhereClause = "ClassID=" + this.OID
};
ICursor cursor = this.MapTemplateGallery.MapTemplateTable.Search(queryFilter, false);
IRow row = cursor.NextRow();
int index = this.MapTemplateGallery.MapTemplateTable.FindField("Name");
while (row != null)
{
string str = row.get_Value(index).ToString();
MapCartoTemplateLib.MapTemplate template2 = new MapCartoTemplateLib.MapTemplate(row.OID, this)
{
Name = str
};
this.AddMapTemplate(template2);
row = cursor.NextRow();
}
ComReleaser.ReleaseCOMObject(row);
}
private string method_0(object object_0)
{
if (object_0 is DBNull)
{
return("");
}
IMemoryBlobStream o = object_0 as IMemoryBlobStream;
IPropertySet set = new PropertySetClass();
IObjectStream pstm = new ObjectStreamClass {
Stream = o
};
IPersistStream stream3 = set as IPersistStream;
stream3.Load(pstm);
string str2 = "";
try
{
str2 = set.GetProperty("TK").ToString();
}
catch (Exception)
{
}
ComReleaser.ReleaseCOMObject(stream3);
ComReleaser.ReleaseCOMObject(set);
ComReleaser.ReleaseCOMObject(o);
set = null;
return(str2);
}
public bool Apply()
{
if (this.bool_0)
{
this.bool_0 = false;
if (this.itableDefinition_0 != null)
{
if (this.itableDefinition_0 is ITable)
{
IQueryFilter queryFilter = new QueryFilterClass
{
WhereClause = this.memoEdit.Text
};
try
{
ComReleaser.ReleaseCOMObject((this.itableDefinition_0 as ITable).Search(queryFilter, false));
}
catch (Exception)
{
MessageBox.Show("过滤条件输入错误，请检查!", "错误", MessageBoxButtons.OK, MessageBoxIcon.Hand);
return(false);
}
}
this.itableDefinition_0.DefinitionExpression = this.memoEdit.Text;
}
}
return(true);
}
/// <summary>
/// Queries for the features that satisfies the attribute and/or spatial query as specified by an
/// <paramref name="filter" /> object
/// and executes the specified <paramref name="action" /> on each feature returned from the query.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="filter">The attribute and/or spatial requirement that the features must satisify.</param>
/// <param name="action">The action to take for each feature in the cursor.</param>
/// <param name="recycling">if set to <c>true</c> when a recycling memory for the features is used.</param>
/// <returns>
/// Returns a <see cref="int" /> representing the number of features affected by the action.
/// </returns>
/// <exception cref="System.ArgumentNullException">action</exception>
/// <exception cref="ArgumentNullException">action</exception>
public static int Fetch(this IFeatureClass source, IQueryFilter filter, Func <IFeature, bool> action, bool recycling)
{
if (source == null)
{
return(0);
}
if (action == null)
{
throw new ArgumentNullException("action");
}
int recordsAffected = 0;
using (ComReleaser cr = new ComReleaser())
{
IFeatureCursor cursor = source.Search(filter, recycling);
cr.ManageLifetime(cursor);
foreach (var feature in cursor.AsEnumerable())
{
if (!action(feature))
{
return(recordsAffected);
}
recordsAffected++;
}
}
return(recordsAffected);
}
void IClip.ClipByLayerFileInsideSde(object in_feature, string in_layer_file_path, object clip_feature, string clip_layer_file_path, string out_feature)
{
using (ComReleaser releaser = new ComReleaser())
{
try
{
Geoprocessor gp = new Geoprocessor();
IDataManager _dataManager = new DataManager(this._environment);
ESRI.ArcGIS.AnalysisTools.Clip clipTool = new ESRI.ArcGIS.AnalysisTools.Clip();
//releaser.ManageLifetime(gp);
//releaser.ManageLifetime(clipTool);
//IVariantArray param = new VarArrayClass();
string inlayer = string.Format("{0}.lyr", in_layer_file_path);
string cliplayer = string.Format("{0}.lyr", clip_layer_file_path);
//MessageBox.Show(string.Format("line 61 GExtractTool in={0}, clip={1}", inlayer, cliplayer));
_dataManager.SaveToLayerFile((ILayer)in_feature, inlayer);
_dataManager.SaveToLayerFile((ILayer)clip_feature, cliplayer);
//MessageBox.Show(((IFeatureLayer)in_feature).FeatureClass.AliasName);
gp.SetEnvironmentValue("workspace", this._environment);
clipTool.in_features = inlayer;
clipTool.clip_features = cliplayer;
clipTool.out_feature_class = out_feature;//string.Format("{0}{1}", this._temFullPath, out_feature);//"C:\\tayninh\\temp\\tempmdb.mdb\\" + out_feature;
runTool(gp, clipTool, null);
}
catch (Exception err) { MessageBox.Show("loi clip: " + err.ToString()); }
}
}
/// <summary>
/// Queries for the rows that satisfy the attribute query as specified by an <paramref name="filter" /> object
/// and executes the specified <paramref name="action" /> on each row returned from the query.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="filter">The attribute requirement that features must satisify.</param>
/// <param name="action">The action to take for each feature in the cursor.</param>
/// <param name="recycling">
/// if set to <c>true</c> when the cursor rehydrates a single row object on each fetch and can be
/// used to optimize read-only access.
/// </param>
/// <returns>
/// Returns a <see cref="int" /> representing the number of rows affected by the action.
/// </returns>
/// <exception cref="System.ArgumentNullException">action</exception>
/// <exception cref="ArgumentNullException">action</exception>
/// <remarks>
/// Uses a recycling cursors rehydrate a single feature object on each fetch and can be used to optimize read-only
/// access
/// </remarks>
public static int Fetch(this ITable source, IQueryFilter filter, Action <IRow> action, bool recycling)
{
if (source == null)
{
return(0);
}
if (action == null)
{
throw new ArgumentNullException("action");
}
int recordsAffected = 0;
using (ComReleaser cr = new ComReleaser())
{
ICursor cursor = source.Search(filter, recycling);
cr.ManageLifetime(cursor);
foreach (var row in cursor.AsEnumerable())
{
action(row);
recordsAffected++;
}
}
return(recordsAffected);
}
private static bool FeatureLayerIdentify(IBasicMap ibasicMap_0, IFeatureLayer ifeatureLayer_0,
IGeometry igeometry_0, IArray iarray_0)
{
bool flag;
ISpatialFilter spatialFilterClass = new SpatialFilter()
{
Geometry = igeometry_0,
SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects
};
try
{
IFeatureCursor featureCursor = ifeatureLayer_0.FeatureClass.Search(spatialFilterClass, false);
for (IFeature i = featureCursor.NextFeature(); i != null; i = featureCursor.NextFeature())
{
AEFeatureIdentifyObject aEFeatureIdentifyObject = new AEFeatureIdentifyObject()
{
BasicMap = ibasicMap_0,
Feature = i
};
iarray_0.Add(aEFeatureIdentifyObject);
}
ComReleaser.ReleaseCOMObject(featureCursor);
flag = true;
return(flag);
}
catch (Exception exception)
{
Logger.Current.Error("", exception, "");
}
flag = false;
return(flag);
}
public void RefreshCurrentPageDataTable()
{
using (ComReleaser comreleaser = new ComReleaser())
{
IFeatureCursor cursor = TargetFeatureClass.Search(null, false);
comreleaser.ManageLifetime(cursor);
IFeature tempFt = cursor.NextFeature();
comreleaser.ManageLifetime(tempFt);
ISet <int> IngoreFieldIndex = ConvertIngoreColName2FieldIndex();
for (int index = 0; index < FeatureCount; index++)
{
if (index < CurrentPage * PageContains)
{
tempFt = cursor.NextFeature();
}
else if (index > (CurrentPage + 1) * PageContains)
{
break;
}
else
{
int colIndex = 0;
DataRow tempRow = ResultTable.NewRow();
for (int i = 0; i < TargetFeatureClass.Fields.FieldCount; i++)
{
if (IngoreFieldIndex.Contains(i))
{
continue;
}
tempRow[colIndex++] = tempFt.get_Value(index);
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="table"></param>
/// <param name="filter"></param>
/// <param name="readOnly"></param>
/// <param name="funcLoopBody">(row, current record count 1-based)</param>
/// <returns>Looped record count.</returns>
public static int Loop(ITable table, IQueryFilter filter, bool readOnly, Func <IRow, int, bool> funcLoopBody)
{
IRow row;
int count = 0;
bool continueLoop = true;
using (ComReleaser comReleaser = new ComReleaser())
{
ICursor cursor = table.Search(filter, readOnly);
comReleaser.ManageLifetime(cursor);
while ((row = cursor.NextRow()) != null)
{
count++;
if (funcLoopBody != null)
{
continueLoop = funcLoopBody(row, count);
if (continueLoop == false)
{
break;
}
}
}
}
return(count);
}
public IList <T> QuerySingleFieldValue <T>(ITable targetTable, string QueryFieldName, string whereclause = null)
{
IList <T> result = new List <T>();
int colIndex = -1;
if ((colIndex = targetTable.FindField(QueryFieldName)) == -1)
{
return(result);
}
IQueryFilter filter = new QueryFilter();
if (string.IsNullOrEmpty(whereclause))
{
filter.WhereClause = whereclause;
}
filter.SubFields = QueryFieldName;
using (ComReleaser releaser = new ComReleaser())
{
ICursor cursor = targetTable.Search(filter, false);
IRow row = cursor.NextRow();
while (row != null)
{
result.Add(row.get_Value(colIndex));
row = cursor.NextRow();
}
}
return(result.Cast <T>().ToList());
}
private void OutputTxt(string shpfile, string txtPath)
{
FileInfo finfo = new FileInfo(shpfile);
string parFolder = System.IO.Path.GetDirectoryName(shpfile);
if (!Directory.Exists(parFolder))
{
Directory.CreateDirectory(parFolder);
}
IWorkspaceFactory shpwf = new ShapefileWorkspaceFactory();
IFeatureWorkspace featureWs = shpwf.OpenFromFile(parFolder, 0) as IFeatureWorkspace;
IFeatureClass featureclass = featureWs.OpenFeatureClass(finfo.Name);
IFeatureCursor cursor = featureclass.Search(null, false);
IFeature pfeat = cursor.NextFeature();
StringBuilder sb = new StringBuilder();
sb.Append("ID,x,y,z\r\n");
int index = 1;
while (pfeat != null)
{
IPoint pt = pfeat.Shape as IPoint;
sb.Append(string.Format("{0},{1},{2},{3}\r\n", index++, pt.X, pt.Y, pt.Z));
pfeat = cursor.NextFeature();
}
ComReleaser.ReleaseCOMObject(cursor);
ComReleaser.ReleaseCOMObject(pfeat);
ComReleaser.ReleaseCOMObject(featureclass);
ComReleaser.ReleaseCOMObject(shpwf);
File.WriteAllText(txtPath, sb.ToString(), Encoding.Default);
}
public void CreateAllRecordTable(bool ColNameUseAlias = false)
{
NotifyDestoryResultTable();
CreateNullRecordTable(ColNameUseAlias);
ISet <int> IngoreFieldIndex = ConvertIngoreColName2FieldIndex();
using (ComReleaser comreleaser = new ComReleaser())
{
IFeatureCursor cursor = TargetFeatureClass.Search(null, false);
comreleaser.ManageLifetime(cursor);
IFeature tempFt = cursor.NextFeature();
comreleaser.ManageLifetime(tempFt);
while (tempFt != null)
{
int colIndex = 0;
DataRow tempRow = ResultTable.NewRow();
for (int index = 0; index < TargetFeatureClass.Fields.FieldCount; index++)
{
if (IngoreFieldIndex.Contains(index))
{
continue;
}
tempRow[colIndex++] = tempFt.get_Value(index);
}
ResultTable.Rows.Add(tempRow);
tempFt = cursor.NextFeature();
}
}
IngoreFieldIndex.Clear();
}
private IElement method_2(object object_0)
{
IMemoryBlobStream o = object_0 as IMemoryBlobStream;
IPropertySet set = new PropertySetClass();
IObjectStream pstm = new ObjectStreamClass
{
Stream = o
};
ESRI.ArcGIS.esriSystem.IPersistStream stream3 = set as ESRI.ArcGIS.esriSystem.IPersistStream;
stream3.Load(pstm);
IElement property = null;
try
{
property = set.GetProperty("Element") as IElement;
}
catch (Exception)
{
}
ComReleaser.ReleaseCOMObject(stream3);
ComReleaser.ReleaseCOMObject(set);
ComReleaser.ReleaseCOMObject(o);
set = null;
return(property);
}
protected override void OnClick()
{
string tablePath = Path.Combine(DataPath, @"Geodatabase\ManhattanKS.gdb\ParcelIDs");
string tableName = Path.GetFileName(tablePath);
const string searchField = "PID";
Type factoryType = Type.GetTypeFromProgID("esriDataSourcesGDB.FileGDBWorkspaceFactory");
IWorkspaceFactory workspaceFactory = Activator.CreateInstance(factoryType) as IWorkspaceFactory;
IWorkspace workspace = workspaceFactory.OpenFromFile(Path.GetDirectoryName(tablePath), 0);
IObjectClassDescription objClassDesc = new ObjectClassDescriptionClass();
IFields fields = objClassDesc.RequiredFields;
IFieldsEdit fieldsEdit = (IFieldsEdit) fields;
IField field = new FieldClass();
IFieldEdit fieldEdit = (IFieldEdit) field;
fieldEdit.Name_2 = searchField;
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldEdit.IsNullable_2 = true;
fieldEdit.AliasName_2 = searchField;
fieldEdit.Editable_2 = true;
fieldEdit.Length_2 = 250;
fieldsEdit.AddField(field);
fields = fieldsEdit;
ITable table = CreateTable((IWorkspace2) workspace, tableName, fields);
using (ComReleaser releaser = new ComReleaser())
{
ICursor cursor = table.Insert(true);
releaser.ManageLifetime(cursor);
string txtPath = Path.Combine(DataPath, "UniqueValues.txt");
int searchFieldIndex = table.FindField(searchField);
IRowBuffer buffer = table.CreateRowBuffer();
using (StreamReader reader = new StreamReader(txtPath))
{
string line;
while ((line = reader.ReadLine()) != null)
{
string id = line.Split(new[] {'.', ' '}, StringSplitOptions.RemoveEmptyEntries)[1];
buffer.Value[searchFieldIndex] = id;
cursor.InsertRow(buffer);
}
cursor.Flush();
}
}
((ITableCollection) ArcMap.Document.FocusMap).AddTable(table);
ArcMap.Document.UpdateContents();
Marshal.FinalReleaseComObject(table);
}
private static Dictionary<string, int> GetAllValues(string fieldName, IGeoFeatureLayer layer)
{
var results = new Dictionary<string, int>();
IQueryFilter query = new QueryFilter { SubFields = fieldName };
using (var comReleaser = new ComReleaser())
{
IFeatureCursor cursor = layer.Search(query, true);
comReleaser.ManageLifetime(cursor);
IFeature feature;
int fieldIndex = cursor.FindField(fieldName);
while ((feature = cursor.NextFeature()) != null)
{
results[feature.Value[fieldIndex].ToString()] = 1;
}
}
return results;
}
public static void UpdateFeature(IFeatureClass featureClass)
{
// Create a COM releaser for cursor management
using (ComReleaser comReleaser = new ComReleaser())
{
// Use IFeatureClass.Update to create an update cursor
IFeatureCursor featureCursor = featureClass.Update(null, true);
comReleaser.ManageLifetime(featureCursor);
// find the index of the field named "country"
int fieldIndex = featureClass.FindField("Country");
IFeature feature = null;
while ((feature = featureCursor.NextFeature()) != null)
{
feature.set_Value(fieldIndex, "USA");
featureCursor.UpdateFeature(feature); // Do not use IFeature.Store with UpdateCursors
}
}
}
private static Dictionary<object, List<Observation>> GetObservations(ITable table)
{
var observationData = new Dictionary<object, List<Observation>>();
using (var comReleaser = new ComReleaser())
{
ICursor cursor = table.Search(null, true);
comReleaser.ManageLifetime(cursor);
IRow row;
while ((row = cursor.NextRow()) != null)
{
string data = string.Format("{0},{1},\"{2}\",{3},\"{4}\"", row.Value[10], row.Value[11], row.Value[3], row.Value[4], row.Value[5]);
string comment = string.Format("\"{0}\"", row.Value[6]);
object gpsId = row.Value[12];
if (observationData.ContainsKey(gpsId))
observationData[gpsId].Add(new Observation {Data = data, Comment = comment});
else
observationData[gpsId] = new List<Observation>
{new Observation {Data = data, Comment = comment}};
}
}
return observationData;
}
///<summary>Flash geometry on the display.</summary>
///<param name="geometry"> The input IGeometry to flash. Supported geometry types are GeometryBag, Polygon, Polyline, Point and Multipoint.</param>
///<param name="screenDisplay">An IScreenDisplay reference</param>
///<param name="delay">An integer that is the time in milliseconds to wait.</param>
public static void FlashGeometry(IGeometry geometry, IScreenDisplay screenDisplay, int delay, int times)
{
if (geometry == null || screenDisplay == null)
{
return;
}
bool continueFlashing = true;
using (ComReleaser comReleaser = new ComReleaser())
{
ITrackCancel cancelTracker = new CancelTrackerClass();
comReleaser.ManageLifetime(cancelTracker);
screenDisplay.CancelTracker = cancelTracker;
short cacheID = screenDisplay.AddCache();
int cacheMemDC = screenDisplay.get_CacheMemDC(cacheID);
IRgbColor fillColor = new RgbColorClass();
comReleaser.ManageLifetime(fillColor);
fillColor.Green = 128;
IRgbColor lineColor = new RgbColorClass();
comReleaser.ManageLifetime(lineColor);
screenDisplay.StartDrawing(cacheMemDC, cacheID);
DrawGeometry(geometry, fillColor, lineColor, (IDisplay)screenDisplay, cancelTracker);
ESRI.ArcGIS.esriSystem.tagRECT RECT = new tagRECT();
screenDisplay.FinishDrawing();
for (int j = 0; j < times; j++)
{
if (continueFlashing == true)
{
screenDisplay.DrawCache(screenDisplay.hDC, cacheID, ref RECT, ref RECT);
if (delay > 0)
{
System.Threading.Thread.Sleep(delay);
screenDisplay.Invalidate(null, true, cacheID);
screenDisplay.UpdateWindow();
System.Threading.Thread.Sleep(delay);
}
}
}
//---------------------------------------------------------------------
screenDisplay.RemoveCache(cacheID);
cancelTracker.Reset();
}
}
void IFeatureClassManager.DeleteFcInSde(string data)
{
using (ComReleaser releaser = new ComReleaser())
{
_workspaceEdit = (IWorkspaceEdit)_workspace;
_mWorkspaceEdit = (IMultiuserWorkspaceEdit)_workspace;
IFeatureWorkspace fw = (IFeatureWorkspace)_workspace;
IFeatureClass fc=null;
//releaser.ManageLifetime(_workspaceEdit);
//releaser.ManageLifetime(_mWorkspaceEdit);
//releaser.ManageLifetime(fw);
//releaser.ManageLifetime(fc);
try
{
fc = fw.OpenFeatureClass(data);
}
catch
{
return;
}
_mWorkspaceEdit.StartMultiuserEditing(esriMultiuserEditSessionMode.esriMESMVersioned);
_workspaceEdit.StartEditOperation();
try
{
((IDataset)fc).Delete();
_workspaceEdit.StartEditOperation();
_workspaceEdit.StopEditing(true);
}
catch (Exception ex)
{
_workspaceEdit.AbortEditOperation();
_workspaceEdit.StopEditing(false);
}
}
}
protected override void OnClick()
{
try
{
if (_wkspHelper.CurrentWorkspace == null)
{
MessageBox.Show("You must select and open a telecom workspace before running this tool");
return;
}
DialogResult res = MessageBox.Show(null, "This test may run for a considerable time (15+ minutes) and may make modifications to the database to resolve issues. \n\nConsider taking a backup before doing this. \n\nDo you wish to proceed?", "DB Integrity Check", MessageBoxButtons.OKCancel);
if (res != DialogResult.OK)
return;
IFeatureClass cableFc = _wkspHelper.FindFeatureClass(ConfigUtil.FiberCableFtClassName);
if (cableFc == null) { return; }
IFeatureWorkspace fworkspace =_wkspHelper.CurrentWorkspace;
if (fworkspace == null) { return; }
// --------------------------------------------
// Check the integrity of the cable feature class
// --------------------------------------------
IRelationshipClass fiberCableToFiberRc = fworkspace.OpenRelationshipClass(ConfigUtil.FiberCableToFiberRelClassName);
IRelationshipClass fiberCableToBufferRc = fworkspace.OpenRelationshipClass(ConfigUtil.FiberCableToBufferRelClassName);
IFeature feature;
bool badCable = false;
bool badBuffers = false;
bool badFibers = false;
bool conversionRequired = false;
IWorkspaceEdit2 edit = fworkspace as IWorkspaceEdit2;
ITransactions transaction = edit as ITransactions;
edit.StartEditing(true);
edit.StartEditOperation();
IQueryFilter qf = new QueryFilter();
qf.AddField(ConfigUtil.NumberOfBuffersFieldName);
qf.AddField(ConfigUtil.NumberOfFibersFieldName);
qf.AddField(ConfigUtil.IpidFieldName);
using (ComReleaser comReleaser = new ComReleaser())
{
IFeatureCursor fCursor = (IFeatureCursor)cableFc.Update(qf, false);
ICursor pCursor = fCursor as ICursor;
comReleaser.ManageLifetime(fCursor);
int buffersFieldIdx = cableFc.FindField(ConfigUtil.NumberOfBuffersFieldName);
int fibersFieldIdx = cableFc.FindField(ConfigUtil.NumberOfFibersFieldName);
int ipidFieldIdx = cableFc.FindField(ConfigUtil.IpidFieldName);
int count = 0;
while ((feature = fCursor.NextFeature()) != null)
{
// Cables should have non null field values
if (feature.get_Value(ipidFieldIdx) == DBNull.Value)
{
badCable = true;
_logHelper.addLogEntry(DateTime.Now.ToString(), "INTEGRITY", "Found Fiber Cable with NULL IPID value");
continue;
}
if (feature.get_Value(buffersFieldIdx) == DBNull.Value)
{
badBuffers = true;
_logHelper.addLogEntry(DateTime.Now.ToString(), "INTEGRITY", "Found Fiber Cable with NULL buffer field value", "Cable ID: " + feature.get_Value(ipidFieldIdx).ToString());
continue;
}
if (feature.get_Value(fibersFieldIdx) == DBNull.Value)
{
badFibers = true;
_logHelper.addLogEntry(DateTime.Now.ToString(), "INTEGRITY", "Found Fiber Cable with NULL fiber field value", "Cable ID: " + feature.get_Value(ipidFieldIdx).ToString());
continue;
}
int bufferCount = (int)feature.get_Value(buffersFieldIdx);
int fiberCount = (int)feature.get_Value(fibersFieldIdx);
// Cables should have non zero values
if (bufferCount == 0)
{
badBuffers = true;
_logHelper.addLogEntry(DateTime.Now.ToString(), "INTEGRITY", "Found Fiber Cable with 0 buffer field value", "Cable ID: " + feature.get_Value(ipidFieldIdx).ToString());
continue;
}
if (fiberCount == 0)
{
badFibers = true;
_logHelper.addLogEntry(DateTime.Now.ToString(), "INTEGRITY", "Found Fiber Cable with 0 strand field value", "Cable ID: " + feature.get_Value(ipidFieldIdx).ToString());
continue;
}
// Cables should have relationships
int rcBufferCount = fiberCableToBufferRc.GetObjectsRelatedToObject(feature).Count;
if (rcBufferCount == 0)
{
badBuffers = true;
_logHelper.addLogEntry(DateTime.Now.ToString(), "INTEGRITY", "Found Fiber Cable with 0 related buffers", "Cable ID: " + feature.get_Value(ipidFieldIdx).ToString());
continue;
}
int rcFiberCount = fiberCableToFiberRc.GetObjectsRelatedToObject(feature).Count;
if (rcFiberCount == 0)
{
badFibers = true;
_logHelper.addLogEntry(DateTime.Now.ToString(), "INTEGRITY", "Found Fiber Cable with 0 related fibers", "Cable ID: " + feature.get_Value(ipidFieldIdx).ToString());
continue;
}
// Buffer field count & relationships to buffers not matching
if (bufferCount != rcBufferCount)
{
badBuffers = true;
String output = "Expected: " + bufferCount + " Found: " + rcBufferCount + " Cable ID: " + feature.get_Value(ipidFieldIdx).ToString();
_logHelper.addLogEntry(DateTime.Now.ToString(), "INTEGRITY", "Found Fiber Cable with buffer count->relationship mismatch", output);
continue;
}
// other checks
if (rcFiberCount % rcBufferCount != 0)
{
badFibers = true;
_logHelper.addLogEntry(DateTime.Now.ToString(), "INTEGRITY", "Fiber Cable with invalid strand count - (relationships % buffercount) is non zero", "Cable ID: " + feature.get_Value(ipidFieldIdx).ToString());
continue;
}
// we must be dealing with a total count (convert to per buffer tube value)
if (fiberCount == rcFiberCount && bufferCount > 1)
{
count++;
Debug.Write(count + " Strand Total to Strands Per Buffer conversion", " Cable ID: " + feature.get_Value(ipidFieldIdx).ToString() + "\n");
conversionRequired = true;
// _logHelper.addLogEntry(DateTime.Now.ToString(), "INTEGRITY", "Strand Total to Strands Per Buffer conversion", "Cable ID: " + feature.get_Value(ipidFieldIdx).ToString());
feature.set_Value(fibersFieldIdx, rcFiberCount / rcBufferCount);
feature.Store();
}
}
}
edit.StopEditOperation();
edit.StopEditing(true);
if (badCable)
MessageBox.Show("Database integrity issues were detected. Found invalid Fiber Cable. Please see the log file for more details");
if (badBuffers)
MessageBox.Show("Database integrity issues were detected. Found Fiber Cable with buffer count issues. Please see the log file for more details");
if (badFibers)
MessageBox.Show("Database integrity issues were detected. Found Fiber Cable with strands count issues. Please see the log file for more details");
if (conversionRequired)
MessageBox.Show("Database integrity issues were detected. Strand Total to Strands Per Buffer conversion was done.");
}
catch (Exception e)
{
_logHelper.addLogEntry(DateTime.Now.ToString(), "ERROR", "Integrity Check Error", e.Message);
}
MessageBox.Show("The results of the DB checks are listed in the tools Log window");
}
private static void Main(string[] args)
{
try
{
// ESRI License Initializer generated code.
if (!arcobjectsLicenseInitializer.InitializeApplication(new esriLicenseProductCode[] { esriLicenseProductCode.esriLicenseProductCodeEngine, esriLicenseProductCode.esriLicenseProductCodeBasic, esriLicenseProductCode.esriLicenseProductCodeStandard, esriLicenseProductCode.esriLicenseProductCodeAdvanced }, new esriLicenseExtensionCode[] { }))
{
Console.WriteLine(arcobjectsLicenseInitializer.LicenseMessage());
Console.WriteLine("This application could not initialize with the correct ArcGIS license and will shutdown.");
arcobjectsLicenseInitializer.ShutdownApplication();
return;
}
var options = new Options();
Parser parser = new Parser();
if (args.Length == 0 || args[0] == "-h" || args[0].Trim().ToLowerInvariant() == "help")
{
Console.WriteLine(options.GetUsage());
Console.WriteLine("Press any key to continue ...");
Console.ReadKey();
return;
}
if (parser.ParseArguments(args, options))
{
if (!Helper.ExistsFileGdb(options.PathAndFGDB))
{
Console.WriteLine("Filegeodatabase '{0}' not exists!", options.PathAndFGDB);
Console.WriteLine("Press any key to continue ...");
Console.ReadKey();
return;
}
IWorkspace workspace = Helper.FileGdbWorkspaceFromPath(options.PathAndFGDB);
IFeatureWorkspace featureWorkspace = workspace as IFeatureWorkspace;
string inputFeatureClassName = options.FeatureClassNameInput ?? "Points";
IWorkspace2 workspace2 = workspace as IWorkspace2;
if (!workspace2.get_NameExists(esriDatasetType.esriDTFeatureClass, inputFeatureClassName))
{
Console.WriteLine("FeatureClass '{0}' not exists in filegeodatabase '{1}'!", inputFeatureClassName, options.PathAndFGDB);
Console.WriteLine("Press any key to continue ...");
Console.ReadKey();
return;
}
IFeatureClass featureClassPoints = featureWorkspace.OpenFeatureClass(inputFeatureClassName);
if (featureClassPoints.ShapeType != esriGeometryType.esriGeometryPoint)
{
Console.WriteLine("FeatureClass '{0}' is not type point!", inputFeatureClassName);
Console.WriteLine("Press any key to continue ...");
Console.ReadKey();
return;
}
string outputFeatureClassName = options.FeatureClassNameOutput ?? "Polygons";
if (workspace2.get_NameExists(esriDatasetType.esriDTFeatureClass, outputFeatureClassName))
{
Console.Write("\nThe featureClass '{0}' exists. You want to overwrite it? Y/N ", outputFeatureClassName);
while (true)
{
ConsoleKeyInfo answer = Console.ReadKey(true);
if (answer.Key == ConsoleKey.N)
{
return;
}
else if (answer.Key == ConsoleKey.Y)
{
Console.Write("\n");
break;
}
else
{
Console.Write("\nPlease select a valid option (Y/N)!");
}
}
IDataset outputDataset = (IDataset)featureWorkspace.OpenFeatureClass(outputFeatureClassName);
if (outputDataset.CanDelete())
{
outputDataset.Delete();
}
else
{
Console.WriteLine("FeatureClass '{0}' couldn't be deleted", outputFeatureClassName);
Console.WriteLine("Press any key to continue ...");
Console.ReadKey();
return;
}
}
IFeatureClass featureClassPolygons = Program.CreateFeatureClassOutput(workspace, Helper.GetSpatialReference(featureClassPoints), outputFeatureClassName);
List<IPoint> locations = new List<IPoint>();
using (ComReleaser comReleaser = new ComReleaser())
{
IFeatureCursor cursor = featureClassPoints.Search(null, true);
comReleaser.ManageLifetime(cursor);
IFeature feature = null;
while ((feature = cursor.NextFeature()) != null)
{
IPoint p = feature.ShapeCopy as IPoint;
locations.Add(p);
}
}
IList<IGeometry> thiessenPolygons = Triangulation.GeometryVoronoi(locations);
int idxId = featureClassPolygons.FindField(Program.nameFieldIdOutput);
int i = 0;
StringBuilder errorGeneratePolygon = new StringBuilder();
foreach (IGeometry pg in thiessenPolygons)
{
i++;
try
{
IFeature feature = featureClassPolygons.CreateFeature();
feature.Shape = pg as IPolygon;
feature.set_Value(idxId, i);
feature.Store();
}
catch (Exception ex)
{
errorGeneratePolygon.AppendLine(string.Format("Polygon id: {0} - Error: Message[{1}]\r\nSource[{2}]\r\nTrace[{3}]", i, ex.Message, ex.Source, ex.StackTrace));
errorGeneratePolygon.AppendLine();
}
}
string errorResult = errorGeneratePolygon.ToString();
if (!string.IsNullOrEmpty(errorResult))
{
Console.WriteLine(errorResult);
Console.WriteLine("Create polygons voronoi with errors!");
}
else
{
Console.WriteLine("Create polygons voronoi with success!");
}
Console.WriteLine("Press any key to continue ...");
Console.ReadKey();
}
else
{
Console.WriteLine(options.GetUsageError());
Console.WriteLine("Press any key to continue ...");
Console.ReadKey();
}
}
catch (Exception ex)
{
Console.WriteLine("Error: Message[{0}]\r\nSource[{1}]\r\nTrace[{2}]", ex.Message, ex.Source, ex.StackTrace);
Console.WriteLine("Press any key to continue ...");
Console.ReadKey();
}
finally
{
try
{
// ESRI License Initializer generated code.
// Do not make any call to ArcObjects after ShutDownApplication()
arcobjectsLicenseInitializer.ShutdownApplication();
}
catch
{
}
}
}
private void addValuesToPointsFC(string prfName)
{
using (ComReleaser comReleaser = new ComReleaser())
{
if( pointsFC == null || profileData == null) return;
List<List<double>> data = profileData.Where(c => c[3] > -999).ToList();
//Spatialreference
ISpatialReference srs = view.FocusMap.SpatialReference;
// Create a feature buffer.
IFeatureBuffer featureBuffer = pointsFC.CreateFeatureBuffer();
comReleaser.ManageLifetime(featureBuffer);
// Create an insert cursor.
IFeatureCursor insertCursor = pointsFC.Insert(true);
comReleaser.ManageLifetime(insertCursor);
foreach (List<double> row in data)
{
IPoint fromXY; IPoint toXY;
IPolyline4 geom = (IPolyline4)polyLineLam72;
fromXY = new PointClass();
geom.QueryPoint(esriSegmentExtension.esriNoExtension, row[0], false, fromXY);
//reproject the point
toXY = geopuntHelper.Transform(fromXY as IGeometry, map.SpatialReference) as IPoint;
featureBuffer.Shape = toXY as IGeometry;
int naamIdx = pointsFC.FindField("naam");
featureBuffer.set_Value(naamIdx, prfName);
int AfstandIdx = pointsFC.FindField("Afstand");
featureBuffer.set_Value(AfstandIdx, row[0]);
int HoogteIdx = pointsFC.FindField("Hoogte");
featureBuffer.set_Value(HoogteIdx, row[3]);
insertCursor.InsertFeature(featureBuffer);
}
insertCursor.Flush();
}
}
object ICopyFeatures.CopyBulkFeature(IFeature copiedFeature, IFeatureClass toFeatureClass)
{
// Create a ComReleaser for cursor management.
using (ComReleaser comReleaser = new ComReleaser())
{
// Create and manage a feature buffer.
IFeatureBuffer featureBuffer = toFeatureClass.CreateFeatureBuffer();
comReleaser.ManageLifetime(featureBuffer);
// Create and manage an insert cursor.
IFeatureCursor featureCursor = toFeatureClass.Insert(true);
comReleaser.ManageLifetime(featureCursor);
featureBuffer.Shape = copiedFeature.ShapeCopy;
featureCursor.InsertFeature(featureBuffer);
// Attempt to flush the buffer.
featureCursor.Flush();
//MessageBox.Show(string.Format("line 529 DataManager \n{0}", featureBuffer.get_Value(0)));
//return featureBuffer.get_Value(0);
return 1;
}
}
public void DeleteShapeFile(string shapeFilePath)
{
string fcName = System.IO.Path.GetFileName(shapeFilePath);
string folderName = System.IO.Path.GetDirectoryName(shapeFilePath);
using (ComReleaser oComReleaser = new ComReleaser())
{
IWorkspaceFactory workspaceFactory = new ShapefileWorkspaceFactory();
IWorkspace workspace = workspaceFactory.OpenFromFile(folderName, 0);
IFeatureWorkspace fWorkspace = (IFeatureWorkspace)workspace;
IDataset ipDs = fWorkspace.OpenFeatureClass(fcName) as IDataset;
ipDs.Delete();
File.Delete(shapeFilePath);
System.Runtime.InteropServices.Marshal.FinalReleaseComObject(workspace);
workspace = null;
fWorkspace = null;
ipDs = null;
}
GC.Collect();
}
internal static void ThreadMain(SearchCandidateProviderProfile profile, TaskCompletionSource<SearchCandidateProvider> createComplete)
{
using (var mainReleaser = new ComReleaser())
{
try
{
var profileMgr = mainReleaser.CreateComObject<ITfInputProcessorProfileMgr>();
if (profile == null)
{
var keyboardGuid = Guids.GUID_TFCAT_TIP_KEYBOARD;
var activeProfile = default(TF_INPUTPROCESSORPROFILE);
if (!profileMgr.GetActiveProfile(ref keyboardGuid, out activeProfile))
{
return;
}
if (activeProfile.dwProfileType == TF_PROFILETYPE.TF_PROFILETYPE_KEYBOARDLAYOUT)
{
// This is not a TIP.
return;
}
profile = new SearchCandidateProviderProfile(activeProfile.langid.ToCultureInfo(), activeProfile.clsid, activeProfile.guidProfile);
}
var name = profile.Name;
var langid = profile.LangId;
var clsid = profile.Clsid;
var profileGuid = profile.ProfileGuid;
if (!profileMgr.ActivateProfile(TF_PROFILETYPE.TF_PROFILETYPE_INPUTPROCESSOR, langid, ref clsid, ref profileGuid, IntPtr.Zero, TF_IPPMF.TF_IPPMF_DONTCARECURRENTINPUTLANGUAGE))
{
return;
}
var threadMgr = mainReleaser.CreateComObject<ITfThreadMgr2>();
var clientId = TextFrameworkDeclarations.TF_CLIENTID_NULL;
if (!threadMgr.ActivateEx(out clientId, default(TF_TMAE)))
{
return;
}
mainReleaser.RegisterCleanup(() => threadMgr.Deactivate());
var functionProvider = mainReleaser.ReceiveObject((out ITfFunctionProvider _) => threadMgr.GetFunctionProvider(ref clsid, out _));
if (functionProvider == null)
{
return;
}
if (string.IsNullOrEmpty(name))
{
functionProvider.GetDescription(out name);
}
var guidNull = new Guid();
var iid = typeof(ITfFnSearchCandidateProvider).GUID;
var searchCandidateProvider = mainReleaser.ReceiveObject((out object _) => functionProvider.GetFunction(ref guidNull, ref iid, out _)) as ITfFnSearchCandidateProvider;
if (searchCandidateProvider == null)
{
return;
}
if (string.IsNullOrEmpty(name))
{
searchCandidateProvider.GetDisplayName(out name);
}
// Refresh the |profile| with the latest |name|.
profile = new SearchCandidateProviderProfile(profile.LangId.ToCultureInfo(), profile.Clsid, profile.ProfileGuid, name);
// It's time to enter the event loop.
using (var queue = new BlockingCollection<RequestQueueItem>())
{
createComplete.SetResult(new SearchCandidateProvider { RequestQueue = queue, Profile = profile });
foreach (var task in queue.GetConsumingEnumerable())
{
using (var releaser = new ComReleaser())
{
var stopWatch = Stopwatch.StartNew();
var response = task.Response;
try
{
var result = searchCandidateProvider.GetSearchCandidates(task.Query).ToArray();
response.SetResult(new SearchCandidateResponse(profile, task.Query, result, stopWatch.Elapsed));
}
catch (Exception e)
{
if (!response.Task.IsCompleted)
{
response.SetResult(new SearchCandidateResponse(profile, task.Query, Enumerable.Empty<string>().ToArray(), stopWatch.Elapsed, e));
}
}
finally
{
if (!response.Task.IsCompleted)
{
response.SetResult(new SearchCandidateResponse(profile, task.Query, Enumerable.Empty<string>().ToArray(), stopWatch.Elapsed));
}
}
}
}
}
}
catch (Exception e)
{
if (!createComplete.Task.IsCompleted)
{
createComplete.SetException(e);
}
}
finally
{
if (!createComplete.Task.IsCompleted)
{
createComplete.SetResult(null);
}
}
}
}
/// <summary>insert the records from the GIPOD service into the shapefile </summary>
private void populateGipodShape(IFeatureClass gipodFC, List<datacontract.gipodResponse> gipodRecords, dataHandler.gipodtype gtype)
{
//return if something is null
if (gipodFC == null || gipodRecords == null) return;
//get the srs
ISpatialReference srs = view.FocusMap.SpatialReference;
using (ComReleaser comReleaser = new ComReleaser())
{
// Create a feature buffer.
IFeatureBuffer featureBuffer = gipodFC.CreateFeatureBuffer();
comReleaser.ManageLifetime(featureBuffer);
// Create an insert cursor.
IFeatureCursor insertCursor = gipodFC.Insert(true);
comReleaser.ManageLifetime(insertCursor);
foreach (datacontract.gipodResponse row in gipodRecords)
{
Double x = row.coordinate.coordinates[0];
Double y = row.coordinate.coordinates[1];
IPoint pt = new PointClass() { X = x, Y = y, SpatialReference = lam72 };
IPoint toPt = geopuntHelper.Transform(pt, srs) as IPoint;
featureBuffer.Shape = toPt;
int id = row.gipodId;
int idIdx = gipodFC.FindField("gipodID");
featureBuffer.set_Value(idIdx, id);
string owner = row.owner;
if (owner.Length > 254) owner = owner.Substring(0, 254);
int ownerIdx = gipodFC.FindField("owner");
featureBuffer.set_Value(ownerIdx, owner);
//sometime very long, handle that
string description = row.description.Replace("\n", " ").Replace("\r", "");
int descriptionIdx = gipodFC.FindField("info");
int maxLen = featureBuffer.Fields.get_Field(descriptionIdx).Length;
if (description.Length > maxLen)
{
description = description.Substring(0, maxLen);
}
featureBuffer.set_Value(descriptionIdx, description);
DateTime startDate = row.startDateTime;
int startDateIdx = gipodFC.FindField("beginDate");
featureBuffer.set_Value(startDateIdx, startDate);
DateTime endDate = row.endDateTime;
int endDateIdx = gipodFC.FindField("endDate");
featureBuffer.set_Value(endDateIdx, endDate);
int hinder = row.importantHindrance ? 1 : 0;
int hinderIdx = gipodFC.FindField("hinder");
featureBuffer.set_Value(hinderIdx, hinder);
string detail = String.Format("http://www.geopunt.be/kaart?app=Hinder_in_kaart_app&GIPODID={0}&maximize=1", row.gipodId);//row.detail;
if (detail.Length > 254) detail = detail.Substring(0, 254);
int detailIdx = gipodFC.FindField("link");
featureBuffer.set_Value(detailIdx, detail);
string cities = string.Join(", ", row.cities.ToArray());
if (cities.Length > 254) cities = cities.Substring(0, 254);
int citiesIdx = gipodFC.FindField("cities");
featureBuffer.set_Value(citiesIdx, cities);
if (gtype == dataHandler.gipodtype.manifestation)
{
string initiator = row.initiator ;
if (initiator != null) {
if (initiator.Length > 254) initiator = initiator.Substring(0, 254);
int initiatorIdx = gipodFC.FindField("initiatief");
featureBuffer.set_Value(initiatorIdx, initiator);
}
string eventType = row.eventType ;
if (eventType != null) {
if (eventType.Length > 254) eventType = eventType.Substring(0, 254);
int eventTypeIdx = gipodFC.FindField("eventType");
featureBuffer.set_Value(eventTypeIdx, eventType);
}
string recurrencePattern = row.recurrencePattern ;
if (recurrencePattern != null) {
if (recurrencePattern.Length > 254) recurrencePattern = recurrencePattern.Substring(0, 254);
int recurrencePatternIdx = gipodFC.FindField("patroon");
featureBuffer.set_Value(recurrencePatternIdx, recurrencePattern);
}
}
insertCursor.InsertFeature(featureBuffer);
}
insertCursor.Flush();
}
}
private static void WriteTable(StreamWriter tw, IFeatureWorkspace workspace, string dateWhereClause)
{
//Get the Featureclasses
IFeatureClass gpsPoints = workspace.OpenFeatureClass("GpsPoints");
IFeatureClass observations = workspace.OpenFeatureClass("Observations");
IFeatureClass birdGroups = workspace.OpenFeatureClass("BirdGroups");
IFeatureClass tracks = workspace.OpenFeatureClass("Tracks");
// Get the Relationship Class Factory
Type memRelClassFactoryType = Type.GetTypeFromProgID("esriGeodatabase.MemoryRelationshipClassFactory");
var memRelClassFactory = (IMemoryRelationshipClassFactory)Activator.CreateInstance(memRelClassFactoryType);
// Get the RelQueryTable factory.
Type rqtFactoryType = Type.GetTypeFromProgID("esriGeodatabase.RelQueryTableFactory");
var rqtFactory = (IRelQueryTableFactory)Activator.CreateInstance(rqtFactoryType);
//Must create the relationship class in memory (don't load from fgdb), else NO outer join.
//IRelationshipClass rc = featureWorkspace.OpenRelationshipClass("GpsPoint_Observation");
// You can't do an left outer join with a one-to-many relationship
//(many-to-one relationships are not supported and right outer joins are not supported)
// must set first parameter to false to make the many table the sourece (i.e. to get all the records in the many table)
// you must leave the first parameter to true to get all the records in the left table for the outer join.
//
//Solution is to create two tables and do the join in my code. Yuck!
IRelationshipClass relationship1 = memRelClassFactory.Open("Obs_Bg",
observations, "ObservationID", birdGroups, "ObservationID",
String.Empty, String.Empty, esriRelCardinality.esriRelCardinalityOneToMany);
//Last parameter must be true to get a left outer join (right outer join if first param is false).
//if first parameter is false, then tables are swapped. Must swap tables to get many to 1 (source/origin/left to dest/foriegn/right)
var table1 = (ITable)rqtFactory.Open(relationship1, false, null, null, String.Empty, false, false);
#if DEBUG
tw.WriteLine("table1"); DebugPrintTable(tw, table1);
#endif
var observationData = GetObservations(table1);
IRelationshipClass relationship2 = memRelClassFactory.Open("Gps_Tracks",
gpsPoints, "TrackID", tracks, "TrackID",
String.Empty, String.Empty, esriRelCardinality.esriRelCardinalityOneToOne);
//Last parameter must be true in order to do a query on the table. Observed, not documented.
var table2 = (ITable)rqtFactory.Open(relationship2, true, null, null, String.Empty, false, true);
#if DEBUG
tw.WriteLine("table2"); DebugPrintTable(tw, table2);
#endif
//filter results to only the year requested.
var query = new QueryFilter {WhereClause = dateWhereClause};
//Query does not sort correctly when doing outer joins
//Can't use query when sorting by time point time and transect start
//((IQueryFilterDefinition)query).PostfixClause = "ORDER BY GpsPoints.Time_local";
tw.WriteLine(
"TRANSECT_ID,DATE_LOCAL,TIME_LOCAL,VESSEL,"+
"RECORDER,OBSERVER_1,OBSERVER_2,BEAUFORT,"+
"WEATHER_CODE,VISIBILITY,LATITUDE_WGS84,LONGITUDE_WGS84," +
"UTM8_EASTING,UTM8_NORTHING,SPEED,BEARING," +
"ANGLE,DISTANCE,BEHAVIOR,GROUP_SIZE,"+
"SPECIES,ON_TRANSECT,PROTOCOL_ID,GPS_STATUS,"+
"SATELLITES,HDOP,TRACK_LENGTH,COMMENTS,"+
"DATA_QUALITY,DATA_QUALITY_CODE");
var lines = new List<Line>();
var lengths = new Dictionary<string, Dictionary<string, double>>();
var transectLengths = new Dictionary<string, double>();
using (var comReleaser = new ComReleaser())
{
//ICursor is a one pass object. We search twice, once to get tracklengths by transect;
ICursor cursor = table2.Search(query, true);
comReleaser.ManageLifetime(cursor);
IRow row;
while ((row = cursor.NextRow()) != null)
{
string transect = row.Value[26].ToString();
bool ontransect = Boolean.Parse(row.Value[28].ToString());
string trackId = row.Value[25].ToString();
var tracklength = (double)row.Value[29];
if (!lengths.ContainsKey(transect))
lengths[transect] = new Dictionary<string, double>();
//skip tracks I've already seen
if (!lengths[transect].ContainsKey(trackId))
if (ontransect)
lengths[transect][trackId] = tracklength;
}
//Sum up the on-transect tracks for each transect
foreach (var length in lengths)
{
if (!transectLengths.ContainsKey(length.Key))
transectLengths[length.Key] = 0;
foreach (var trackLength in length.Value)
{
transectLengths[length.Key] += trackLength.Value;
}
}
var emptyObservationList = new List<Observation>{new Observation{Data = ",,,,", Comment=""}};
//Second search to format output
cursor = table2.Search(query, true);
while ((row = cursor.NextRow()) != null)
{
var utm = (IPoint)row.Value[1];
var localDateTime = (DateTime) row.Value[6];
var trackDateTime = (DateTime) row.Value[20];
string date = localDateTime.ToString("yyyy-MM-dd");
string time = localDateTime.ToString("HH:mm:ss");
string transect = row.Value[26].ToString();
object gpsId = row.Value[13];
List<Observation> observationList = observationData.ContainsKey(gpsId) ? observationData[gpsId] : emptyObservationList;
foreach (var observation in observationList)
{
var sb = new StringBuilder();
sb.AppendFormat("\"{0}\",\"{1}\",\"{2}\",\"{3}\",", transect, date, time, row.Value[16]);
sb.AppendFormat("\"{0}\",\"{1}\",\"{2}\",\"{3}\",", row.Value[17], row.Value[18], row.Value[19], row.Value[24]);
sb.AppendFormat("\"{0}\",{1},{2},{3},", row.Value[23], row.Value[22], row.Value[3], row.Value[4]);
sb.AppendFormat("{0},{1},{2},{3},", utm.X, utm.Y, row.Value[10], row.Value[11]);
sb.AppendFormat("{0},", observation.Data);
sb.AppendFormat("\"{0}\",\"{1}\",{2},", row.Value[28], row.Value[27], row.Value[12]);
sb.AppendFormat("{0},{1},{2},{3},", row.Value[8], row.Value[7], transectLengths[transect], observation.Comment);
sb.Append(",,");
lines.Add(new Line { Date = localDateTime, TrackDate = trackDateTime, Text = sb.ToString() });
}
}
}
lines.Sort();
foreach (var line in lines)
tw.WriteLine(line.Text);
}
private static void DebugPrintTable(StreamWriter tw, ITable table)
{
using (var comReleaser = new ComReleaser())
{
ICursor cursor = table.Search(null, true);
comReleaser.ManageLifetime(cursor);
IRow row;
var sb = new StringBuilder();
int c = table.Fields.FieldCount;
for (int i = 0; i < c; i++)
sb.AppendFormat("\"{0}\",", table.Fields.Field[i].Name);
tw.WriteLine(sb.ToString());
while ((row = cursor.NextRow()) != null)
{
sb = new StringBuilder();
for (int i = 0; i < c; i++)
sb.AppendFormat("\"{0}\",", row.Value[i]);
tw.WriteLine(sb.ToString());
}
}
}
public static void InsertFeaturesUsingCursor(IFeatureClass featureClass, List<IGeometry> geometryList)
{
using (ComReleaser comReleaser = new ComReleaser())
{
IFeatureBuffer featureBuffer = featureClass.CreateFeatureBuffer();
comReleaser.ManageLifetime(featureBuffer);
IFeatureCursor insertCursor = featureClass.Insert(true);
comReleaser.ManageLifetime(insertCursor);
int typeFieldIndex = featureClass.FindField("Name");
int i = 1;
foreach (IGeometry geometry in geometryList)
{
featureBuffer.Shape = geometry;
featureBuffer.set_Value(typeFieldIndex, i++.ToString());
insertCursor.InsertFeature(featureBuffer);
}
insertCursor.Flush();
}
}
public void IteratioRecyclingTest()
{
IFeatureClass feacl = loadFeatureClasFromFolder(@"E:\data", "origin");
if (feacl == null)
return;
using (ComReleaser comReleaser = new ComReleaser())
{
IFeatureCursor feaCursor = feacl.Search(null, true);
comReleaser.ManageLifetime(feaCursor);
IFeature fea1 = feaCursor.NextFeature();
if (fea1 == null)
return;
int index = feacl.FindField("FinalScore");
while (fea1 != null)
{
object ovalue = fea1.get_Value(index);
fea1.set_Value(index, Convert.ToDouble(ovalue) + 100);
fea1.Store();
Console.WriteLine(Convert.ToDouble(ovalue));
//fea1.Store();
fea1 = feaCursor.NextFeature();
}
}
}
private void weigthingOnFeatureClass(IFeatureClass feacls, string[] strFields, double[] weights)
{
int[] index = new int[strFields.Length];
for (int i = 0; i < index.Length; i++)
{
index[i] = feacls.FindField(strFields[i]);
}
int scoreIndex=feacls.FindField("FinalScore");
int Count=1;
using (ComReleaser comReleaser = new ComReleaser())
{
IFeatureCursor cursor = feacls.Search(null, false);
comReleaser.ManageLifetime(cursor);
IFeature feature = cursor.NextFeature();
while (feature != null)
{
double weightedscore = 0;
for (int j=0;j<index.Length;j++)
{
object obj=feature.get_Value(index[j]);
if (obj is DBNull)
obj = feature.Fields.get_Field(index[j]).DefaultValue;
weightedscore+=weights[j]*Convert.ToDouble(obj);
}
feature.set_Value(scoreIndex,weightedscore);
feature.Store();
Console.WriteLine(Count + " finished");
Count++;
feature = cursor.NextFeature();
}
}
}
private void addScoreToolStripMenuItem_Click(object sender, EventArgs e)
{
IFeatureLayer fealyr = axMapControl1.get_Layer(0) as IFeatureLayer;
IFeatureClass feacls = fealyr.FeatureClass;
IField field = new FieldClass();
IFieldEdit2 fe = field as IFieldEdit2;
fe.Name_2 = "FinalScore";
fe.Type_2 = esriFieldType.esriFieldTypeDouble;
feacls.AddField(field);
int index = feacls.FindField("FinalScore");
object obj = null;
Random rand = new Random();
using (ComReleaser com = new ComReleaser())
{
IFeatureCursor cursor = feacls.Search(null, true);
com.ManageLifetime(cursor);
IFeature fea = cursor.NextFeature();
while (fea != null)
{
obj = rand.NextDouble() * 100;
fea.set_Value(index, obj);
fea.Store();
fea = cursor.NextFeature();
}
}
}
/// <summary>
/// Export graphics to a shapefile
/// </summary>
/// <param name="fileNamePath">Path to shapefile</param>
/// <param name="graphicsList">List of graphics for selected tab</param>
/// <param name="ipSpatialRef">Spatial Reference being used</param>
/// <returns>Created featureclass</returns>
private IFeatureClass ExportToShapefile(string fileNamePath, List<Graphic> graphicsList, ISpatialReference ipSpatialRef)
{
int index = fileNamePath.LastIndexOf('\\');
string folder = fileNamePath.Substring(0, index);
string nameOfShapeFile = fileNamePath.Substring(index + 1);
string shapeFieldName = "Shape";
IFeatureClass featClass = null;
using (ComReleaser oComReleaser = new ComReleaser())
{
try
{
IWorkspaceFactory workspaceFactory = null;
workspaceFactory = new ShapefileWorkspaceFactoryClass();
IWorkspace workspace = workspaceFactory.OpenFromFile(folder, 0);
IFeatureWorkspace featureWorkspace = workspace as IFeatureWorkspace;
IFields fields = null;
IFieldsEdit fieldsEdit = null;
fields = new Fields();
fieldsEdit = (IFieldsEdit)fields;
IField field = null;
IFieldEdit fieldEdit = null;
field = new FieldClass();///###########
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Shape";
fieldEdit.Type_2 = (esriFieldType.esriFieldTypeGeometry);
IGeometryDef geomDef = null;
IGeometryDefEdit geomDefEdit = null;
geomDef = new GeometryDefClass();///#########
geomDefEdit = (IGeometryDefEdit)geomDef;
//This is for line shapefiles
geomDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolyline;
geomDefEdit.SpatialReference_2 = ipSpatialRef;
fieldEdit.GeometryDef_2 = geomDef;
fieldsEdit.AddField(field);
////Add another miscellaneous text field
//field = new FieldClass();
//fieldEdit = (IFieldEdit)field;
//fieldEdit.Length_2 = 30;
//fieldEdit.Name_2 = "TextField";
//fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
//fieldsEdit.AddField(field);
featClass = featureWorkspace.CreateFeatureClass(nameOfShapeFile, fields, null, null, esriFeatureType.esriFTSimple, shapeFieldName, "");
foreach (Graphic graphic in graphicsList)
{
IFeature feature = featClass.CreateFeature();
feature.Shape = graphic.Geometry;
feature.Store();
}
IFeatureLayer featurelayer = null;
featurelayer = new FeatureLayerClass();
featurelayer.FeatureClass = featClass;
featurelayer.Name = featClass.AliasName;
System.Runtime.InteropServices.Marshal.FinalReleaseComObject(workspace);
workspace = null;
GC.Collect();
return featClass;
}
catch (Exception ex)
{
return featClass;
}
}
}
public long unversionedEdit(IQueryFilter qFilterGen, int sequenceColumnNum, int idxSeqField, int curLoop, ref ITransactions transactions)
{
long sequenceValue = -1;
using (ComReleaser comReleaser = new ComReleaser())
{
if (AAState._gentabWorkspace.IsInEditOperation)
{
// throw new Exception("Cannot use ITransactions during an edit operation.");
}
// Begin a transaction.
if (transactions == null)
{
transactions = (ITransactions)AAState._gentabWorkspace;
}
transactions.StartTransaction();
try
{
// Use ITable.Update to create an update cursor.
ICursor seq_updateCursor = AAState._gentab.Update(qFilterGen, true);
comReleaser.ManageLifetime(seq_updateCursor);
IRow seq_row = null;
seq_row = seq_updateCursor.NextRow();
int sequenceInt = 1;
if (seq_row != null)
{
if (idxSeqField > 0)
{
object seqInt = seq_row.get_Value(idxSeqField);
if (seqInt != null)
{
if (seqInt != DBNull.Value)
try
{
sequenceInt = Convert.ToInt32(seqInt);
}
catch
{
}
}
}
object seqValue = seq_row.get_Value(sequenceColumnNum);
if (seqValue == null)
{
sequenceValue = 0;
}
else if (seqValue.ToString() == "")
{
sequenceValue = 0;
}
else
try
{
sequenceValue = Convert.ToInt64(seqValue);
}
catch
{
sequenceValue = 0;
}
AAState.WriteLine(" " + sequenceValue + " is the existing value and the interval is " + sequenceInt + ": " + DateTime.Now.ToString("h:mm:ss tt"));
sequenceValue = sequenceValue + sequenceInt;
seq_row.set_Value(sequenceColumnNum, sequenceValue);
AAState.WriteLine(" " + seq_row.Fields.get_Field(sequenceColumnNum).AliasName + " changed to " + sequenceValue + ": " + DateTime.Now.ToString("h:mm:ss tt"));
seq_updateCursor.UpdateRow(seq_row);
transactions.CommitTransaction();
seq_updateCursor = AAState._gentab.Search(qFilter, true);
if (seq_row != null)
{
seqValue = seq_row.get_Value(sequenceColumnNum);
if (seqValue == null)
{
return sequenceValue;
}
else if (seqValue.ToString() == "")
{
return sequenceValue;
}
else
try
{
if (sequenceValue == Convert.ToInt64(seqValue))
{
return sequenceValue;
}
else
{
if (curLoop > 30)
{
MessageBox.Show("A unique ID could not be generated after 30 attempts: " + DateTime.Now.ToString("h:mm:ss tt"));
}
else
{
return unversionedEdit(qFilterGen, sequenceColumnNum, idxSeqField, curLoop + 1, ref transactions);
}
}
}
catch
{
return sequenceValue;
}
}
return sequenceValue;
}
else
{
AAState.WriteLine(" No records found in Generate ID table" + ": " + DateTime.Now.ToString("h:mm:ss tt"));
transactions.AbortTransaction();
return -1;
}
}
catch (COMException comExc)
{
AAState.WriteLine(" Error saving transaction to DB" + ": " + DateTime.Now.ToString("h:mm:ss tt"));
// If an error occurs during the inserts and updates, rollback the transaction.
transactions.AbortTransaction();
return -1;
}
}
}
public bool InsertNewRow(ITable table,IWorkspaceEdit workspace)
{
using (ComReleaser comReleaser = new ComReleaser())
{
try
{
multiWspEdit.StartMultiuserEditing(esriMultiuserEditSessionMode.esriMESMVersioned);
workspace.StartEditOperation();
_currentRow = table.CreateRow();
_currentRow.Store();
workspace.StopEditOperation();
workspace.StopEditing(true);
return true;
}
catch {
workspace.StopEditOperation();
workspace.StopEditing(false);
return false; }
}
}
/// <summary>
/// 4.去除多边形内的空白区域
/// 多边形面积/空白面积>3
/// </summary>
/// <param name="radio"></param>
private void RemoveBlankSpace(IFeatureClass feacls,double radio)
{
//确定多边形内存在环，且环中无其他多边形
using(ComReleaser com=new ComReleaser())
{
IFeatureCursor cursor = feacls.Update(null, true);
com.ManageLifetime(cursor);
IFeature fea = cursor.NextFeature();
while (fea != null)
{
IPolygon3 poly = fea.Shape as IPolygon3;
IGeometryCollection geomCollection = poly as IGeometryCollection;
if (geomCollection.GeometryCount <= 1)
{
fea = cursor.NextFeature();
continue;
}
else
{
/* IRing ring = null;
IRing exRing = null;
List<IRing> rlist = new List<IRing>();
for (int i = 0; i < geomCollection.GeometryCount; i++)
{
ring = geomCollection.get_Geometry(i) as IRing;
if (ring.IsExterior)
{
exRing = ring;
continue;
}
rlist.Add(ring);
}
IArea area = exRing as IArea;
double extArea = area.Area;
foreach (IRing item in rlist)
{
double inArea = ((IArea)item).Area;
if(extArea/inArea>3)
{
item.SetEmpty();
}
}
geomCollection.GeometriesChanged();
fea.Store();
fea = cursor.NextFeature();*/
int i = 0;
while(i<geomCollection.GeometryCount)
{
IRing ring = geomCollection.get_Geometry(i) as IRing;
if(ring.IsExterior)
{
i++;
continue;
}
else
{
geomCollection.RemoveGeometries(i, 1);
geomCollection.GeometriesChanged();
continue;
}
}
fea.Store();
fea = cursor.NextFeature();
}
}
}
}
private static void PutGridInFeatureClass(IFeatureClass featureClass, Grid grid)
{
using (var comReleaser = new ComReleaser())
{
// Create a feature buffer.
IFeatureBuffer featureBuffer = featureClass.CreateFeatureBuffer();
comReleaser.ManageLifetime(featureBuffer);
// Create an insert cursor.
IFeatureCursor insertCursor = featureClass.Insert(true);
comReleaser.ManageLifetime(insertCursor);
// All of the features to be created are classified as Primary Highways.
int colFieldIndex = featureClass.FindField("Col");
int rowFieldIndex = featureClass.FindField("Row");
int colLabelFieldIndex = featureClass.FindField("Col_Label");
int rowLabelFieldIndex = featureClass.FindField("Row_Label");
int cellLabelFieldIndex = featureClass.FindField("Cell_Label");
int pageFieldIndex = featureClass.FindField("Page");
foreach (Cell cell in grid.Cells)
{
featureBuffer.Shape = cell.Shape;
featureBuffer.Value[colFieldIndex] = cell.Column;
featureBuffer.Value[rowFieldIndex] = cell.Row;
featureBuffer.Value[colLabelFieldIndex] = cell.ColumnLabel;
featureBuffer.Value[rowLabelFieldIndex] = cell.RowLabel;
featureBuffer.Value[cellLabelFieldIndex] = cell.Label;
featureBuffer.Value[pageFieldIndex] = cell.Page;
insertCursor.InsertFeature(featureBuffer);
}
// Flush the buffer to the geodatabase.
insertCursor.Flush();
}
}
void IFeatureClassManager.DeleteFeatureClass(IDataset data)
{
using (ComReleaser releaser = new ComReleaser())
{
_workspaceEdit = (IWorkspaceEdit)_workspace;
_mWorkspaceEdit = (IMultiuserWorkspaceEdit)_workspace;
//releaser.ManageLifetime(_workspaceEdit);
//releaser.ManageLifetime(_mWorkspaceEdit);
_mWorkspaceEdit.StartMultiuserEditing(esriMultiuserEditSessionMode.esriMESMVersioned);
_workspaceEdit.StartEditOperation();
try
{
data.Delete();
_workspaceEdit.StartEditOperation();
_workspaceEdit.StopEditing(true);
}
catch (Exception ex)
{
_workspaceEdit.AbortEditOperation();
_workspaceEdit.StopEditing(false);
}
}
//fcThuaCliped = fw.OpenFeatureClass("thua_sau50m_clip");
//IDataset ft = (IDataset)fcThuaCliped;
}
/// <summary>
/// 1.数据预处理
/// 遍历整个Feature Class 完成
/// 获取打分字段最大最小值
/// 去除不合理狭长区域（数据本身存在问题）
/// 去除极小块斑点 50平米
/// </summary>
private void PreProcessingData(out double minval, out double maxval, double deleteArea, double radio)
{
minval = 0;
maxval = 0;
using (ComReleaser comReleaser = new ComReleaser())
{
//IFeatureCursor feaCursor = m_FeaCls.Search(null, true);
IFeatureCursor feaCursor = m_FeaCls.Update(null, true);
int targetIndex = m_FeaCls.FindField(m_PartitionField);
int lengthIndex = m_FeaCls.FindField("Shape_Leng");
int areaIndex = m_FeaCls.FindField("Shape_Area");
comReleaser.ManageLifetime(feaCursor);
IFeature fea = feaCursor.NextFeature();
maxval = Convert.ToDouble(fea.get_Value(targetIndex));
minval = Convert.ToDouble(fea.get_Value(targetIndex));
while (fea != null)
{
double length = Convert.ToDouble(fea.get_Value(lengthIndex));
double area = Convert.ToDouble(fea.get_Value(areaIndex));
if (length / area >= radio)
{
feaCursor.DeleteFeature();
fea = feaCursor.NextFeature();
continue;
}
if (area <= 50)
{
feaCursor.DeleteFeature();
fea = feaCursor.NextFeature();
continue;
}
double tempV = Convert.ToDouble(fea.get_Value(targetIndex));
if (tempV >= maxval)
maxval = tempV;
if (tempV < minval)
minval = tempV;
fea = feaCursor.NextFeature();
}
}
}
private List<string> GetNames()
{
if (_data == null)
throw new Exception("Unable to build this picklist due to invalid (or unvalidated) configuration properties.");
var results = new List<string>();
using(var comReleaser = new ComReleaser())
{
ICursor cursor = _data.Search(null, true);
comReleaser.ManageLifetime(cursor);
IRow row;
// typically field 0 has the OID, and field 1 has the picklist value
// however if there is only one field, then use it
int index = _data.Fields.FieldCount < 2 ? 0 : 1;
while ((row = cursor.NextRow()) != null)
{
results.Add(row.Value[index].ToString());
}
}
return results;
}
