public static void CopyTable(ITable pSrcTable, ITable pDestTable)
{
Exception exception;
try
{
if ((pSrcTable != null) && (pDestTable != null))
{
List <int> pSrcField = null;
List <int> pDestField = null;
CreateFieldMap(pSrcTable, pDestTable, out pSrcField, out pDestField);
ICursor o = pSrcTable.Search(null, true);
int num = pSrcTable.RowCount(null);
if (num > 0)
{
int num2 = (num / 10) + 1;
IWorkspaceEdit edit = (pDestTable as IDataset).Workspace as IWorkspaceEdit;
edit.StartEditing(false);
edit.StartEditOperation();
IRow pSrcFea = o.NextRow();
int num3 = 1;
while (pSrcFea != null)
{
try
{
if ((num2 >= 1000) && ((num3++ % num2) == 0))
{
edit.StopEditOperation();
edit.StopEditing(true);
edit.StartEditing(false);
edit.StartEditOperation();
}
IRow pDestFea = pDestTable.CreateRow();
CopyRow(pSrcFea, pDestFea, pSrcField, pDestField);
if ((pSrcFea is IFeature) && (pDestFea is IFeature))
{
(pDestFea as IFeature).Shape = (pSrcFea as IFeature).ShapeCopy;
}
pDestFea.Store();
}
catch (Exception exception1)
{
exception = exception1;
}
pSrcFea = o.NextRow();
edit.StopEditOperation();
edit.StopEditing(true);
}
Marshal.ReleaseComObject(o);
}
}
}
catch (Exception exception2)
{
exception = exception2;
}
}
public void DeleteTask(string taskName)
{
IFeatureWorkspace ws = Util.ServerWorkspace as IFeatureWorkspace;
ITable task_tbl = ws.OpenTable("TaskLog");
IQueryFilter filter = new QueryFilterClass();
filter.WhereClause = "TaskName = '" + taskName + "'";
ICursor cur = task_tbl.Search(filter, false);
IRow rw = cur.NextRow();
IWorkspaceEdit wse = ws as IWorkspaceEdit;
if (rw != null)
{
string status = rw.get_Value(task_tbl.FindField("Status")) as string;
if (status == TaskManager.CHECKOUT_STATUS)
{
wse.StartEditing(true);
rw.Delete();
wse.StopEditing(true);
}
else if (status == TaskManager.CHECKIN_STATUS)
{
IVersionedWorkspace vw = ws as IVersionedWorkspace;
IVersion ver = vw.FindVersion(taskName);
ver.Delete();
wse.StartEditing(true);
rw.Delete();
wse.StopEditing(true);
}
wse.StartEditing(false);
ITable tgl_tbl = ws.OpenTable("TaskGridLog");
IQueryFilter tgl_filter = new QueryFilterClass();
tgl_filter.WhereClause = "TaskName = '" + taskName + "'";
tgl_tbl.DeleteSearchedRows(tgl_filter);
wse.StopEditing(true);
IQueryFilter checkItem_filter = new QueryFilterClass();
checkItem_filter.WhereClause = "VersionName = '" + taskName + "'";
wse.StartEditing(false);
ITable checkItemPtn_fc = ws.OpenTable("CheckItemPtn");
checkItemPtn_fc.DeleteSearchedRows(checkItem_filter);
ITable checkItemLn_fc = ws.OpenTable("CheckItemLn");
checkItemLn_fc.DeleteSearchedRows(checkItem_filter);
ITable checkItemPoly_fc = ws.OpenTable("CheckItemPoly");
checkItemPoly_fc.DeleteSearchedRows(checkItem_filter);
wse.StopEditing(true);
}
}
public string AddPolygonTo3D(Dictionary <IPolygon, bool> polygons)
{
string featureClassName = GenerateTemp3DPolygonStorage();
IWorkspaceEdit workspaceEdit = (IWorkspaceEdit)calcWorkspace;
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
IFeatureClass calc = GetCalcProfileFeatureClass(featureClassName);
var GCS_WGS = Helper.GetBasePointSpatialReference();
polygons.ToList().ForEach(polygon =>
{
var pointFeature = calc.CreateFeature();
pointFeature.Shape = polygon.Key;
int isVisibleFieldIndex = calc.FindField("IS_VISIBLE");
pointFeature.set_Value(isVisibleFieldIndex, polygon.Value ? 1 : 0);
pointFeature.Store();
});
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
return(featureClassName);
}
public void AddPolygonByWrite(AxMapControl axMapControl1, IFeatureLayer l, double x, double y)
{
ESRI.ArcGIS.Geometry.esriGeometryType featype = l.FeatureClass.ShapeType;
if (featype == esriGeometryType.esriGeometryPolygon)//判断层是否为线层
{
//IFeatureLayer l = MapCtr.Map.get_Layer(0) as IFeatureLayer;
IFeatureClass fc = l.FeatureClass;
IFeatureClassWrite fr = fc as IFeatureClassWrite;
IWorkspaceEdit w = (fc as IDataset).Workspace as IWorkspaceEdit;
IFeature f;
//可选参数的设置
object Missing = Type.Missing;
IPoint p = new PointClass();
w.StartEditing(true);
w.StartEditOperation();
f = fc.CreateFeature();
//定义一个多义线对象
IRgbColor color = new RgbColor();
// 设置颜色属性
color.Red = 255;
color.Transparency = 255;
IGeometry iGeom = axMapControl1.TrackPolygon();
AddRegion(axMapControl1, iGeom);
f.Shape = iGeom;
fr.WriteFeature(f);
w.StopEditOperation();
w.StopEditing(true);
}
}
protected override void OnClick()
{
IActiveView activeView = ArcMap.Document.ActiveView;
IMap map = activeView as IMap;
ILayer layer = map.get_Layer(0);
IFeatureLayer featureLayer = layer as IFeatureLayer;
IFeatureClass featureClass = featureLayer.FeatureClass;
IPoint point = new PointClass();
point.PutCoords(-117.1, 34.075); //(LONG, LAT)
IWorkspace workspace = GetWorkspace();
IWorkspaceEdit workspaceEdit = workspace as IWorkspaceEdit;
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
// -------------- Perform your editing tests here ------------------
CreateFeature(featureClass, point);
//UpdateFeature(featureClass);
//DeleteFeature(featureClass);
// -----------------------------------------------------------------
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
ArcMap.Application.CurrentTool = null;
}
protected override void OnMouseDown(ESRI.ArcGIS.Desktop.AddIns.Tool.MouseEventArgs arg)
{
IMxDocument pMxDoc = ArcMap.Application.Document as IMxDocument;
IRubberBand pRabber = new RubberPolygon();
//get polygon from screen
IPolygon pPolygon = pRabber.TrackNew(pMxDoc.ActiveView.ScreenDisplay, null) as IPolygon;
//get cordinate from hard coded
//IPolygon pPolygon ;
//IPoint pPoint1 = new Point();
//pPoint1.X = -120.730273;
//pPoint1.Y = 224.928212;
//IPoint pPoint2 = new Point();
//pPoint2.X = -25.280158;
//pPoint2.Y = 27942068.023;
//IPoint pPoint3 = new Point();
//pPoint3.X = -117.895121;
//pPoint3.Y = 150.269211;
//IPointCollection pPointCollection = new Polygon();
//pPointCollection.AddPoint(pPoint1);
//pPointCollection.AddPoint(pPoint2);
//pPointCollection.AddPoint(pPoint3);
//pPointCollection.AddPoint(pPoint1);
//pPolygon = pPointCollection as IPolygon;
////fix when draw wrong draw
//IArea pArea = pPolygon as IArea;
//if (pArea.Area < 0)
//{
// pPolygon.ReverseOrientation();
//}
IFeatureLayer pFlayer = pMxDoc.FocusMap.Layer[0] as IFeatureLayer;
IDataset pDS = pFlayer.FeatureClass as IDataset;
IWorkspaceEdit pWSE = pDS.Workspace as IWorkspaceEdit;
pWSE.StartEditing(false);
pWSE.StartEditOperation();
IFeature pFeature = pFlayer.FeatureClass.CreateFeature();
pFeature.Shape = pPolygon;
pFeature.Store();
pWSE.StopEditOperation();
pWSE.StopEditing(true);
pMxDoc.ActiveView.Refresh();
}
/// <summary>
/// 删除多个几何对象
/// </summary>
/// <param name="lyr">图层</param>
/// <param name="fea">要素对象</param>
/// <param name="attributes">属性集合</param>
/// <param name="pGeo">空间对象</param>
/// <returns>成功失败标志</returns>
public void DelFeatures(IFeatureLayer lyr, string sql)
{
try
{
IFeatureClass Featureclass = lyr.FeatureClass;
if (Featureclass != null)
{
IFeatureCursor featurecursor = PropertySearch(sql, lyr);
IWorkspaceEdit workspace = (IWorkspaceEdit)(Featureclass as IDataset).Workspace;
workspace.StartEditing(false);
workspace.StartEditOperation();
IFeature fea = featurecursor.NextFeature();
while (fea != null)
{
fea.Delete();
fea = featurecursor.NextFeature();
}
workspace.StopEditOperation();
workspace.StopEditing(true);
}
}
catch (Exception ei)
{
Log.Debug("[GIS] Del Feature: " + ei.ToString());
}
}
/// <summary>
/// 将拓扑错误要素存入要素类中
/// </summary>
/// <param name="topoErrorFeatures">拓扑错误要素</param>
/// <param name="resultFeatureClass">保存拓扑错误要素的要素类，注意其坐标系和类型(点/线/面)必须与拓扑错误要素相同</param>
public static void TopoErrorInsertToFeatureClass(this IEnumerable <ITopologyErrorFeature> topoErrorFeatures, IFeatureClass resultFeatureClass)
{
int typeIndex = resultFeatureClass.AddField("TRuleType", "拓扑规则", esriFieldType.esriFieldTypeInteger);
int orClassIdIndex = resultFeatureClass.AddField("OriClsID", "源要素类ID", esriFieldType.esriFieldTypeInteger);
int deClassIdIndex = resultFeatureClass.AddField("DesClsID", "目标要素类ID", esriFieldType.esriFieldTypeInteger);
int orOidIndex = resultFeatureClass.AddField("OriOID", "源要素OID", esriFieldType.esriFieldTypeInteger);
int deOidIndex = resultFeatureClass.AddField("DesOID", "目标要素OID", esriFieldType.esriFieldTypeInteger);
IWorkspaceEdit tmpWorkspaceEdit = (IWorkspaceEdit)(resultFeatureClass as IDataset).Workspace;
tmpWorkspaceEdit.StartEditing(true);
tmpWorkspaceEdit.StartEditOperation();
IFeatureBuffer featureBuffer = resultFeatureClass.CreateFeatureBuffer();
//在目标要素类中插入所有错误要素
IFeatureCursor featureCursor = resultFeatureClass.Insert(true);
foreach (var errorFeature in topoErrorFeatures)
{
IFeature tmpFeature = errorFeature as IFeature;
featureBuffer.set_Value(typeIndex, errorFeature.TopologyRuleType);
featureBuffer.set_Value(orClassIdIndex, errorFeature.OriginClassID);
featureBuffer.set_Value(deClassIdIndex, errorFeature.DestinationClassID);
featureBuffer.set_Value(orOidIndex, errorFeature.OriginOID);
featureBuffer.set_Value(deOidIndex, errorFeature.DestinationOID);
featureBuffer.Shape = tmpFeature.Shape;
object featureOID = featureCursor.InsertFeature(featureBuffer);
}
featureCursor.Flush();//保存要素
tmpWorkspaceEdit.StopEditOperation();
tmpWorkspaceEdit.StopEditing(true);
Marshal.ReleaseComObject(featureCursor);
}
private void testToolStripMenuItem_Click(object sender, EventArgs e)
{
//打开目标数据库
IWorkspaceFactory pAccessWorkspaceFactory;
pAccessWorkspaceFactory = new AccessWorkspaceFactoryClass();
IWorkspace fWorkspace = pAccessWorkspaceFactory.OpenFromFile("E://2018年工作//数据验收平台测试//test.gdb", 0);
IFeatureWorkspace fW = fWorkspace as IFeatureWorkspace;
IEnumDataset penumDatasets = fWorkspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
penumDatasets.Reset();
IDataset pesriDataset = penumDatasets.Next();
while (pesriDataset == null)
{
IFeatureClass pFeatureClass = fW.OpenFeatureClass("Ⅰ级保护林地范围");
}
//启动编辑
IWorkspaceEdit workspaceEdit = (IWorkspaceEdit)fWorkspace;
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
//调用创建拓朴的方法
ITopology topology = Create_Topology(fW, "datset", "Ⅰ级保护林地范围", "Polygon_Topo");
//停止编辑
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
if (topology != null)
{
MessageBox.Show("创建拓朴成功！");
}
}
/// <summary>
/// 删除满足条件的停采线要素
/// </summary>
/// <param name="featureLayer">停采线图层</param>
/// <param name="stopLineID">停采线ID</param>
/// <returns>成功删除返回true</returns>
public static bool DeleteLineFeature(IFeatureLayer featureLayer, string stopLineID)
{
try
{
IFeatureClass featureClass = featureLayer.FeatureClass;
IDataset dataset = (IDataset)featureClass;
IWorkspace workspace = dataset.Workspace;
IWorkspaceEdit workspaceEdit = workspace as IWorkspaceEdit;
workspaceEdit.StartEditing(false);
workspaceEdit.StartEditOperation();
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = string.Format("BID='{0}'", stopLineID);
//Get table and row
ITable esriTable = (ITable)featureLayer.FeatureClass;
esriTable.DeleteSearchedRows(queryFilter);
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
GIS.Common.DataEditCommon.g_pMyMapCtrl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewAll | esriViewDrawPhase.esriViewGeoSelection, null, null);
return(true);
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine("删除停采线要素出错：" + ex.Message);
return(false);
}
}
private void StartEditing()
{
GetCurrentLayer();
if (m_CurrentLayer == null)
{
return;
}
if ((IGeoFeatureLayer)m_CurrentLayer == null)
{
return;
}
IFeatureLayer pFeatureLayer = (IFeatureLayer)m_CurrentLayer;
IDataset pDataset = (IDataset)pFeatureLayer.FeatureClass;
if (pDataset == null)
{
return;
}
IWorkspaceEdit pWorkspaceEdit = (IWorkspaceEdit)pDataset.Workspace;
if (!pWorkspaceEdit.IsBeingEdited())
{
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.EnableUndoRedo();
}
}
protected override void OnMouseUp(ESRI.ArcGIS.Desktop.AddIns.Tool.MouseEventArgs arg)
{
IMxDocument pMxDoc = ArcMap.Application.Document as IMxDocument;
//get point cordinate from map point
// IPoint pPoint = pMxDoc.ActivatedView.ScreenDisplay.DisplayTransformation.ToMapPoint(arg.X, arg.Y);
//get point from hard coded
IPoint pPoint = new Point();
pPoint.X = -126.165462;
pPoint.Y = 136.960535;
IFeatureLayer pFLayer = pMxDoc.FocusMap.Layer[0] as IFeatureLayer;
IWorkspaceEdit pWorkspaceEdit = ((IDataset)(pFLayer.FeatureClass)).Workspace as IWorkspaceEdit;
pWorkspaceEdit.StartEditing(false);
pWorkspaceEdit.StartEditOperation();
IFeature pFeature = pFLayer.FeatureClass.CreateFeature();
pFeature.Shape = pPoint;
pFeature.Store();
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
//for refresh mxd doc
pMxDoc.ActivatedView.Refresh();
}
/// <summary>
/// 配置指定要素的字段
/// </summary>
/// <param name="AnnotationFeatureClass"></param>
/// <param name="AnnotationFeatureCursor"></param>
/// <param name="AnnotationFeature"></param>
public void ConfigFields(IFeatureClass AnnotationFeatureClass, IFeatureCursor AnnotationFeatureCursor, IFeature AnnotationFeature)
{
IWorkspace WorkSpace = ((IDataset)AnnotationFeatureClass).Workspace;
IWorkspaceEdit edit = WorkSpace as IWorkspaceEdit;
bool startEdit = edit.IsBeingEdited();
if (!startEdit)
{
edit.StartEditing(false);
}
edit.StartEditOperation();
try
{
int index = AnnotationFeature.Fields.FindField("Status");
AnnotationFeature.set_Value(index, esriAnnotationStatus.esriAnnoStatusPlaced);
index = AnnotationFeature.Fields.FindField("Angle");
AnnotationFeature.set_Value(index, 90);
index = AnnotationFeature.Fields.FindField("FontName");
AnnotationFeature.set_Value(index, "华文彩云");
}//先找到字段的索引值，再set_Value
catch { }
AnnotationFeature.Store();
System.Runtime.InteropServices.Marshal.ReleaseComObject(AnnotationFeature);
AnnotationFeatureCursor.Flush();
System.Runtime.InteropServices.Marshal.ReleaseComObject(AnnotationFeatureCursor);
edit.StopEditOperation();
startEdit = edit.IsBeingEdited();
if (startEdit)
{
edit.StopEditing(true);
}
}
/// <summary>
///添加点图层
/// </summary>
/// <param name="axMap"></param>
/// <param name="longtitude"></param>
/// <param name="latitude"></param>
/// <param name="fieldsMap"></param>
public static IFeature addPointInLayer(AxMapControl axMap, SharedStory story)
{
try
{
double longitude = Convert.ToDouble(story.Longitude);
double latitude = Convert.ToDouble(story.Latitude);
String storyId = story.Id;
String message = story.Message;
ILayer layer = getLayerByName(axMap.Map, "story");
//将ILayer转换为IFeaturelayer，为了对图层上的要素进行编辑
IFeatureLayer featureLayer = layer as IFeatureLayer;
//定义一个要素集合，并获取图层的要素集合
IFeatureClass featureClass = featureLayer.FeatureClass;
//定义一个实现新增要素的接口实例，并该实例作用于当前图层的要素集
IFeatureClassWrite writer = (IFeatureClassWrite)featureClass;
//定义一个工作编辑工作空间，用于开启前图层的编辑状态
IWorkspaceEdit edit = (featureClass as IDataset).Workspace as IWorkspaceEdit;
//定义一个IFeature实例，用于添加到当前图层上
IFeature feature;
//开启编辑状态
edit.StartEditing(true);
//开启编辑操作
edit.StartEditOperation();
//定义一个点，用来作为IFeature实例的形状属性，即shape属性
IPoint point;
//下面是设置点的坐标和参考系
point = new PointClass();
point.SpatialReference = axMap.SpatialReference;
point.X = longitude;
point.Y = latitude;
//将IPoint设置为IFeature的shape属性时，需要通过中间接口IGeometry转换
IGeometry geometry = point;
//实例化IFeature对象， 这样IFeature对象就具有当前图层上要素的字段信息
feature = featureClass.CreateFeature();
//设置IFeature对象的形状属性
feature.Shape = geometry;
//添加字段
int index = featureClass.FindField("story_id");
feature.Value[index] = storyId;
feature.Store(); //保存IFeature对象
writer.WriteFeature(feature); //将IFeature对象，添加到当前图层上
edit.StopEditOperation(); //停止编辑操作
edit.StopEditing(true); //关闭编辑状态，并保存修改
axMap.Refresh(); //刷新地图
return(feature);
}
catch
{
return(null);
}
}
public void AddFeature(IFeatureLayer fealyr, IGeometry geometry)
{
IFeatureClass featurecls = fealyr.FeatureClass;
if (featurecls.ShapeType != geometry.GeometryType)
{
return; //这个if语句也是迷
}
IDataset dataset = featurecls as IDataset;
IWorkspace workspace = dataset.Workspace;
IWorkspaceEdit workspaceEdit = workspace as IWorkspaceEdit;
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
IFeatureBuffer featurebuffer = featurecls.CreateFeatureBuffer();
featurebuffer.Shape = geometry; ///实锤
////以下代码为测试设置其他字段值
//int index = featureBuffer.Fields.FindField("Name");
//featureBuffer.set_Value(index, "测试点");
IFeatureCursor featurecusor = featurecls.Insert(true);
featurecusor.InsertFeature(featurebuffer);
featurecusor.Flush();
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true); //C#庐山真面目，让你感觉到可以这样写
}
private void CreateFeature(IGeometry geo, IMap pMap, IFeatureClass fc)
{
try
{
if (geo == null || fc == null || pMap == null)
{
return;
}
IDataset pDataset = fc as IDataset;
IWorkspaceEdit pWorkspaceEdit = pDataset.Workspace as IWorkspaceEdit;
int index = fc.FindField(fc.ShapeFieldName);
IGeometryDef pGD = fc.Fields.get_Field(index).GeometryDef;
if (pGD.HasZ)
{
IZAware pZA = geo as IZAware;
pZA.ZAware = true;
IZ pZ = geo as IZ;
double zmin = -1000, zmax = 1000;
if (pGD.SpatialReference.HasZPrecision())
{
pGD.SpatialReference.GetZDomain(out zmin, out zmax);
}
if (pZ != null)
{
pZ.SetConstantZ(0);
}
else
{
IPoint p = geo as IPoint;
if (p.Z.ToString() == "非数字")
{
p.Z = 0;
}
}
}
if (pGD.HasM)
{
IMAware pMA = geo as IMAware;
pMA.MAware = true;
}
if (!pWorkspaceEdit.IsBeingEdited())
{
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.StartEditOperation();
}
IFeature pFeature = fc.CreateFeature();
pFeature.Shape = geo;
pFeature.Store();
if (pWorkspaceEdit.IsBeingEdited())
{
pWorkspaceEdit.StartEditOperation();
pWorkspaceEdit.StopEditing(true);
}
pMap.ClearSelection();
}
catch (System.Exception ex)
{
return;
}
}
private void dataGridViewX_CellValueChanged(object sender, DataGridViewCellEventArgs e)
{
try
{
IFeature pfeature = advTree.SelectedNode.Tag as IFeature;
if (pfeature != null)
{
IWorkspaceEdit iWE = (pfeature.Class as IDataset).Workspace as IWorkspaceEdit;
if (!iWE.IsBeingEdited())
{
iWE.StartEditing(false);
}
iWE.StartEditOperation();
int fdpos = pfeature.Fields.FindFieldByAliasName(dataGridViewX[e.ColumnIndex - 1, e.RowIndex].Value.ToString());
pfeature.set_Value(fdpos, dataGridViewX[e.ColumnIndex, e.RowIndex].Value.ToString());
pfeature.Store();
iWE.StopEditOperation();
labelEditStatus.Text = "已完成更改!";
labelEditStatus.Visible = true;
this.Refresh();
iWE = null;
}
}
catch
{
MessageBox.Show("请按正确的字段格式填写属性！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
/// <summary>
/// 根据查询语句从ITable中删除对应的记录信息
/// </summary>
/// <param name="lyr">图层</param>
/// <param name="sql">查询语句</param>
public void DelFeaturesByQueryFilter(IFeatureLayer lyr, string sql)
{
IFeatureClass Featureclass = lyr.FeatureClass;
IWorkspaceEdit workspace = (IWorkspaceEdit)(Featureclass as IDataset).Workspace;
workspace.StartEditing(false);
workspace.StartEditOperation();
//删除要素
IQueryFilter qfilter = new QueryFilterClass();
qfilter.WhereClause = sql;
ITable table = Featureclass as ITable;
table.DeleteSearchedRows(qfilter);
//停止编辑
try
{
workspace.StopEditOperation();
workspace.StopEditing(true);
}
catch (Exception ei)
{
throw;
}
System.Runtime.InteropServices.Marshal.ReleaseComObject(qfilter);
Global.pActiveView.Refresh();
}
/// <summary>
/// 删除指定图层的指定图形
/// </summary>
/// <param name="id">图形的id</param>
/// <param name="layerName">图层名</param>
public void DeleteFeature(int id, string layerName)
{
InitLicense();
try
{
List <FieldInfo> list = GetAllFields(layerName);
var node = configXml.SelectSingleNode("/Layers/Layer[@Title='" + layerName + "']");
var ws = CreateWorkspace();
IWorkspaceEdit edit = (IWorkspaceEdit)ws;
edit.StartEditing(false);
edit.StartEditOperation();
var fc = ws.OpenFeatureClass(node.Attributes["Name"].Value);
var feature = fc.GetFeature(id);
IFeatureClassWrite fcw = fc as IFeatureClassWrite;
if (feature != null)
{
fcw.RemoveFeature(feature);
}
edit.StopEditOperation();
edit.StopEditing(true);
}
catch (Exception ex)
{
ShutdownLicense();
throw ex;
}
}
/// 合并列表中所有多边形
/// </summary>
/// <param name="orifeature">保留源对象</param>
/// <param name="geolist">图形列表</param>
/// <returns></returns>
public void CreatePolygonFromExistingGeometries(IFeatureLayer lyr, IFeature orifeature, List <IGeometry> geolist)
{
int i = 0;
IGeometry geometry = null;
IFeatureClass Featureclass = lyr.FeatureClass;
IWorkspaceEdit workspace = (IWorkspaceEdit)(Featureclass as IDataset).Workspace;
workspace.StartEditing(false);
workspace.StartEditOperation();
//合并图形
ITopologicalOperator2 topologicalOperator2 = orifeature.ShapeCopy as ITopologicalOperator2;
for (i = 0; i < geolist.Count; i++)
{
IGeometry geo = geolist[i];
if (geometry != null)
{
topologicalOperator2 = geometry as ITopologicalOperator2;
}
ITopologicalOperator opertor = geo as ITopologicalOperator;
opertor.Simplify();
topologicalOperator2.IsKnownSimple_2 = false;
topologicalOperator2.Simplify();
geometry = topologicalOperator2.Union(geo);
}
//更新图形对象
IGeometry geoCombined = (IGeometry)geometry;
orifeature.Shape = geoCombined as IGeometry;
orifeature.Store();
workspace.StopEditOperation();
workspace.StopEditing(true);
}
/// <summary>
/// 获取绘制点的图层——Cities, 保存点绘制的函数
/// </summary>
/// <param name="pointLayerName"></param>
/// <param name="point"></param>
private void AddPointByStore(string pointLayerName, IPoint pt)
{
//得到要添加地物的图层
IFeatureLayer pFeatureLayer = GetLayerByName(pointLayerName) as IFeatureLayer;
if (pFeatureLayer != null)
{
//定义一个地物类, 把要编辑的图层转化为定义的地物类
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
//先定义一个编辑的工作空间, 然后将其转化为数据集, 最后转化为编辑工作空间
IWorkspaceEdit w = (pFeatureClass as IDataset).Workspace as IWorkspaceEdit;
IFeature pFeature;
//开始事务操作
w.StartEditing(false);
//开始编辑
w.StartEditOperation();
//创建一个(点)要素
pFeature = pFeatureClass.CreateFeature();
//赋值该要素的Shape属性
pFeature.Shape = pt;
//保存要素, 完成点要素生成
//此时生成的点要素只要集合特征(shape/Geometry), 无普通属性
pFeature.Store();
//结束编辑
w.StopEditOperation();
//结束事务操作
w.StopEditing(true);
}
//屏幕刷新
this.axMapControl1.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, pFeatureLayer, null);
}
/// <summary>
/// 开始编辑
/// </summary>
/// <param name="bWithUndoRedo"></param>
public void StartEditing(bool WithUndoRedo)
{
if (MyselectedLayer == null)
{
return;
}
IFeatureLayer featureLayer = MyselectedLayer as IFeatureLayer;
if (featureLayer == null)
{
return;
}
IFeatureClass featureClass = featureLayer.FeatureClass;
if (featureClass == null)
{
return;
}
IDataset dataset = featureClass as IDataset;
IWorkspaceEdit workspaceEdit = dataset.Workspace as IWorkspaceEdit;
try
{
workspaceEdit.StartEditing(WithUndoRedo);
If_isEdited = true;
}
catch
{
return;
}
}
/// <summary>
/// Deletes the anno features in feature layer.
/// </summary>
/// <param name="featureLayer">The feature layer.</param>
public static void DeleteAnnoFeaturesInFeatureLayer(IFeatureLayer featureLayer)
{
if (featureLayer == null)
{
return;
}
IFeatureClass featureClass = featureLayer.FeatureClass;
IDataset dataset = featureClass as IDataset;
IWorkspace pWorkspace = dataset.Workspace;
IWorkspaceEdit pWorkspaceEdit = pWorkspace as IWorkspaceEdit;
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.StartEditOperation();
IWorkspaceProperties2 workspaceProperties2 = (IWorkspaceProperties2)pWorkspace;
//判断workspace是否可以执行SQL语句
IWorkspaceProperty canExecuteSqlProperty =
workspaceProperties2.get_Property(esriWorkspacePropertyGroupType.esriWorkspacePropertyGroup,
(int)esriWorkspacePropertyType.esriWorkspacePropCanExecuteSQL);
if (canExecuteSqlProperty.IsSupported)
{
//ExecuteSQL删除feature
pWorkspace.ExecuteSQL("delete from " + featureClass.AliasName + " where objectid >=0");
}
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
}
//IFeatureClass CreateFeature Example
private IFeature IFeatureClass_Create(IFeatureClass featureClass, IGeometry pGeometry)
{
if (featureClass.ShapeType != ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon)
{
return(null);
}
IWorkspaceEdit iWE = (featureClass as IDataset).Workspace as IWorkspaceEdit;
if (!iWE.IsBeingEdited())
{
iWE.StartEditing(false);
}
IFeature feature = featureClass.CreateFeature();
//Apply the constructed shape to the new features shape
feature.Shape = pGeometry;
ISubtypes subtypes = (ISubtypes)featureClass;
IRowSubtypes rowSubtypes = (IRowSubtypes)feature;
if (subtypes.HasSubtype) // does the feature class have subtypes?
{
rowSubtypes.SubtypeCode = 1; //in this example 1 represents the Primary Pipeline subtype
}
// initalize any default values that the feature has
rowSubtypes.InitDefaultValues();
//Commit the default values in the feature to the database
feature.Store();
iWE.StopEditing(true);
iWE = null;
return(feature);
}
public string AddProfilePointsTo3D(IEnumerable <IPoint> points)
{
string featureClassName = GenerateTemp3DPointStorage();
IWorkspaceEdit workspaceEdit = (IWorkspaceEdit)calcWorkspace;
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
IFeatureClass calc = GetCalcProfileFeatureClass(featureClassName);
var GCS_WGS = Helper.GetBasePointSpatialReference();
int i = 0;
points.ToList().ForEach(point =>
{
var pointFeature = calc.CreateFeature();
int idFieldIndex = calc.FindField("ID");
pointFeature.set_Value(idFieldIndex, i);
pointFeature.Shape = point;
pointFeature.Store();
});
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
return(featureClassName);
}
public void AddPointByWrite(IFeatureLayer l, double x, double y)
{
ESRI.ArcGIS.Geometry.esriGeometryType featype = l.FeatureClass.ShapeType;
if (featype == esriGeometryType.esriGeometryPoint)//判断层是否为点层
{
// IFeatureLayer l = MapCtr.Map.get_Layer(0) as IFeatureLayer;
IFeatureClass fc = l.FeatureClass;
IFeatureClassWrite fr = fc as IFeatureClassWrite;
IWorkspaceEdit w = (fc as IDataset).Workspace as IWorkspaceEdit;
IFeature f;
IPoint p;
w.StartEditing(true);
w.StartEditOperation();
f = fc.CreateFeature();
p = new PointClass();
p.PutCoords(x, y);
f.Shape = p;
fr.WriteFeature(f);
w.StopEditOperation();
w.StopEditing(true);
}
}
public string AddProfileLinesToCalculation(IEnumerable <IPolyline> profileLines)
{
string featureClassName = GenerateTempProfileLinesStorage();
IWorkspaceEdit workspaceEdit = (IWorkspaceEdit)calcWorkspace;
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
IFeatureClass calc = GetCalcProfileFeatureClass(featureClassName);
var GCS_WGS = Helper.GetBasePointSpatialReference();
profileLines.ToList().ForEach(
l =>
{
var newLine = calc.CreateFeature();
newLine.Shape = l;
newLine.Store();
}
);
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
return(featureClassName);
}
/// <summary>
/// 结束任务流程
/// </summary>
/// <param name="taskName"></param>
public void FinishTask(string taskName)
{
IFeatureWorkspace ws = Util.ServerWorkspace as IFeatureWorkspace;
IVersionedWorkspace vw = ws as IVersionedWorkspace;
if (taskName.ToLower() == vw.DefaultVersion.VersionName.ToLower())
{
return;
}
IVersion ver = vw.FindVersion(taskName);
IVersionEdit4 ve = ver as IVersionEdit4;
IWorkspaceEdit wse = ver as IWorkspaceEdit;
wse.StartEditing(true);
ve.Reconcile4(vw.DefaultVersion.VersionName, true, true, true, true);
if (ve.CanPost())
{
ve.Post(vw.DefaultVersion.VersionName);
}
ITable task_tbl = ws.OpenTable("TaskLog");
IQueryFilter filter = new QueryFilterClass();
filter.WhereClause = "TaskName = '" + taskName + "'";
ICursor cur = task_tbl.Search(filter, false);
IRow rw = cur.NextRow();
if (rw != null)
{
rw.set_Value(task_tbl.FindField("Status"), TaskManager.FINISH_STATUS);
rw.set_Value(task_tbl.FindField("FinishDate"), DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"));
rw.Store();
}
wse.StopEditing(true);
ver.Delete();
}
public void ChangeTasksStatus(string taskName, string status)
{
IFeatureWorkspace ws = Util.ServerWorkspace as IFeatureWorkspace;
ITable task_tbl = ws.OpenTable("TaskLog");
IQueryFilter filter = new QueryFilterClass();
filter.WhereClause = "TaskName = '" + taskName + "'";
ICursor cur = task_tbl.Search(filter, false);
IRow rw = cur.NextRow();
IWorkspaceEdit wse = ws as IWorkspaceEdit;
wse.StartEditing(false);
if (rw != null)
{
wse.StartEditOperation();
rw.set_Value(task_tbl.FindField("Status"), status);
if (status == TaskManager.CHECKIN_STATUS)
{
rw.set_Value(task_tbl.FindField("CheckInDate"), DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"));
}
else if (status == TaskManager.AUTOCHECK_STATUS)
{
rw.set_Value(task_tbl.FindField("AutoDataCheckDate"), DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"));
}
else if (status == TaskManager.MANUALCHECK_STATUS)
{
rw.set_Value(task_tbl.FindField("ManualDataCheckDate"), DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"));
}
rw.Store();
wse.StopEditOperation();
}
wse.StopEditing(true);
}
//将检测的错误点添加到该图层，添加相应字段errdsp的错误文本描述
public static void insertChkPoints(string Layername, ArrayList pPoints, string errdsp)
{
IFeatureLayer pFeatureLayer = getFeatureLayer(Layername);
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
IDataset pDataset = (IDataset)pFeatureClass;
IWorkspace pWorkspace = pDataset.Workspace;
IWorkspaceEdit pWorkspaceEdit = (IWorkspaceEdit)pWorkspace;
//开始编辑cglc_chkmarkt图层
pWorkspaceEdit.StartEditing(false); //true编辑后点数据不显示
pWorkspaceEdit.StartEditOperation();
for (int i = 0; i < pPoints.Count; i++)
{
IFeature pFeature = pFeatureClass.CreateFeature();
IPoint pPoint = pPoints[i] as IPoint;
pFeature.Shape = (IPoint)pPoint;
pFeature.set_Value(3, errdsp);
pFeature.Store();
}
//结束图层编辑并保存
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
}
public void ProcessFeature(IWorkspaceEdit iwe, IFeatureLayer ifl_active, IRow rw)
{
double value = double.NaN;
if (CoordinateSystem == "")
{
CoordinateSystem = ((IFeature)rw).Shape.SpatialReference.Name;
}
if (this.LinearUnit == null || this.LinearUnit == "")
{
if (fieldTier == 2)
{
LinearUnit = rw.get_Value(GetFieldUnitIndex()).ToString();
}
if (this.LinearUnit == null || this.LinearUnit.Trim() == "")
{
LinearUnit = GetSpatialReferenceLinearUnit(((IFeature)rw).Shape.SpatialReference);
}
}
if (LinearUnit.IndexOf("meter", 0, StringComparison.CurrentCultureIgnoreCase) > -1)
{
if (useArealUnit)
{
currentAreaUnit = esriAreaUnits.esriSquareMeters;
LinearUnit = "Square Meters";
}
else
{
currentLinearUnit = esriUnits.esriMeters;
}
}
else if (LinearUnit.IndexOf("foot", 0, StringComparison.CurrentCultureIgnoreCase) > -1)
{
if (useArealUnit)
{
currentAreaUnit = esriAreaUnits.esriSquareFeet;
LinearUnit = "Square Feet";
}
else
{
currentLinearUnit = esriUnits.esriFeet;
}
}
else if (LinearUnit.IndexOf("acre", 0, StringComparison.CurrentCultureIgnoreCase) > -1)
{
currentAreaUnit = esriAreaUnits.esriAcres;
currentLinearUnit = esriUnits.esriUnknownUnits;
LinearUnit = "Acres";
}
if (doReCalcValues || !double.TryParse(rw.get_Value(GetFieldIndex()).ToString(), out value) || value == double.NaN || value == 0.0)
{
value = DoMeasure(rw);
//try writing the (single) measured value to the table
try
{
IFeature feat = (IFeature)rw;
//if we are re-calculating all values, there is no need to start editing on each row
if (!doReCalcValues)
{
if (!iwe.IsBeingEdited())
iwe.StartEditing(true);
iwe.StartEditOperation();
}
feat.set_Value(GetFieldIndex(), value);
feat.set_Value(GetFieldUnitIndex(), LinearUnit);
feat.Store();
}
catch (Exception err)
{
}
finally
{
if (!doReCalcValues)
{
iwe.StopEditOperation();
if (iwe.IsBeingEdited())
iwe.StopEditing(true);
//there may be more than one row that requires editing
doReCalcValues = true;
}
}
}
values.Add(value);
}
