/// <summary>
/// 刷新Mobike数据
/// </summary>
public void RefreshmobikeInfo()
{
//获取车辆位置信息
var mobikecars = new List <mobikeInfo>();
NetUtils.GetmobikeCars(out mobikecars);
if (mobikecars == null)
{
view.ShowError("数据出现问题,可能是mobike用户认证出错 返回示例数据");
mobikecars = SampleData.mobikeSampleList;
}
IFeatureClass featureclass = CreateFeatureClass("mobike");
IFeatureCursor featureCursor = featureclass.Insert(true);
//遍历照片链表 以创建缓存的形式插入数据
foreach (var c in mobikecars)
{
IPoint pPoint = new PointClass();
//坐标转换
var t = CoordinateUtils.gcj02_To_Wgs84(c.distY, c.distX);
pPoint.PutCoords(t.longtitude, t.latitude);
pPoint.SpatialReference = ApplicationV.GlobalMapControl.SpatialReference;
pPoint.Project(ApplicationV.GlobalMapControl.SpatialReference);
IFeatureBuffer featureBuffer = featureclass.CreateFeatureBuffer();
featureBuffer.Shape = pPoint;
featureBuffer.set_Value(featureBuffer.Fields.FindField("Latitude"), t.latitude);
featureBuffer.set_Value(featureBuffer.Fields.FindField("Longtitude"), t.longtitude);
featureCursor.InsertFeature(featureBuffer);
}
featureCursor.Flush();
//创建图层
IFeatureLayer pFeaturelayer = new FeatureLayerClass();
pFeaturelayer.FeatureClass = featureclass;
pFeaturelayer.Name = "mobike分布";
//修饰该图层
IPictureMarkerSymbol mobikeMarkerSymbol = new PictureMarkerSymbolClass();
mobikeMarkerSymbol.Size = 18;
mobikeMarkerSymbol.CreateMarkerSymbolFromFile(esriIPictureType.esriIPicturePNG, ApplicationV.Data_ImgPath + "//mobike.png");
// ISimpleMarkerSymbol pMarkerSymbol = new SimpleMarkerSymbol();
// pMarkerSymbol.Style = esriSimpleMarkerStyle.esriSMSCircle;
// var pRgbColor = ColorUtils.GetRgbColor(226, 61, 14);
// pMarkerSymbol.Color = pRgbColor;
ISimpleRenderer pSimpleRenderer = new SimpleRendererClass();
pSimpleRenderer.Symbol = (ISymbol)mobikeMarkerSymbol;
(pFeaturelayer as IGeoFeatureLayer).Renderer = pSimpleRenderer as IFeatureRenderer;
//正式归为图层
ofoLayer = pFeaturelayer as ILayer;
ApplicationV.GlobalMapControl.AddLayer(ofoLayer);
ApplicationV.GlobalMapControl.Refresh();
}
/// <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 method_10(IFeatureBuffer ifeatureBuffer_0, ICoFeature icoFeature_0)
{
foreach (ICoField field in icoFeature_0.Layer.Fields)
{
ICoField field2 = field;
if (this.coLayerMapper_0 != null)
{
field2 = this.coLayerMapper_0.FindDestField(field);
}
if (field2 == null)
{
field2 = field;
}
int index = ifeatureBuffer_0.Fields.FindField(field2.Name);
if ((index > -1) && (index < ifeatureBuffer_0.Fields.FieldCount))
{
Exception exception;
try
{
object obj2 = icoFeature_0.GetValue(field.Name);
IField field3 = ifeatureBuffer_0.Fields.get_Field(index);
if (field3 != null)
{
object obj3 = Class4.ToObjectFun(obj2, field3);
switch (field3.Type)
{
case esriFieldType.esriFieldTypeOID:
case esriFieldType.esriFieldTypeGeometry:
{
continue;
}
}
ifeatureBuffer_0.set_Value(index, obj3);
}
else
{
try
{
ifeatureBuffer_0.set_Value(index, obj2);
}
catch (Exception exception1)
{
exception = exception1;
Debug.WriteLine(exception.Message);
}
}
}
catch (Exception exception2)
{
exception = exception2;
Debug.WriteLine(exception.Message);
}
}
}
}
//将线添加到图层
private void AddFeatureEar(IGeometry geometry, double earv)
{
string pLineFile = txtOutFile.Text;
string pFilePath = System.IO.Path.GetDirectoryName(pLineFile);
string pFileName = System.IO.Path.GetFileName(pLineFile);
//打开工作空间
IWorkspaceFactory pWSF = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace pWS = (IFeatureWorkspace)pWSF.OpenFromFile(pFilePath, 0);
//写入实体对象
IFeatureLayer pFeatureLayer = new FeatureLayerClass();
pFeatureLayer.FeatureClass = pWS.OpenFeatureClass(pFileName);
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
IDataset pDataset = (IDataset)pFeatureClass;
IWorkspace pWorkspace = pDataset.Workspace;
//开始空间编辑
IWorkspaceEdit pWorkspaceEdit = (IWorkspaceEdit)pWorkspace;
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.StartEditOperation();
IFeatureBuffer pFeatureBuffer = pFeatureClass.CreateFeatureBuffer();
IFeatureCursor pFeatureCursor;
//开始插入新的实体对象
pFeatureCursor = pFeatureClass.Insert(true);
pFeatureBuffer.Shape = geometry;
int index = pFeatureBuffer.Fields.FindField("EarthVector");
if (index >= 0)
{
pFeatureBuffer.set_Value(pFeatureBuffer.Fields.FindField("EarthVector"), earv);
}
index = pFeatureBuffer.Fields.FindField("Type");
if (index >= 0)
{
pFeatureBuffer.set_Value(pFeatureBuffer.Fields.FindField("Type"), "Ear");
}
object featureOID = pFeatureCursor.InsertFeature(pFeatureBuffer);
//保存实体
pFeatureCursor.Flush();
//结束空间编辑
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
System.Runtime.InteropServices.Marshal.ReleaseComObject(pFeatureCursor);
}
//将线添加到图层
private void AddFeature(IFeatureLayer pFeatureLayer, List <IPolyline> lineList, List <IPoint> ptsList, List <double> lineLengthList)
{
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
IDataset pDataset = (IDataset)pFeatureClass;
IWorkspace pWorkspace = pDataset.Workspace;
//for (int i = 0; i < lineList.Count; i++)
//{
// if (lineList[i].Length > 0)
// {
// IFeature pFeature = pFeatureClass.CreateFeature();
// pFeature.Shape = lineList[i];
// double sLength = Math.Round((ptsList[i + 1].X - ptsList[i].X) * (ptsList[i + 1].X - ptsList[i].X) + (ptsList[i + 1].Y - ptsList[i].Y) * (ptsList[i + 1].Y - ptsList[i].Y) + (ptsList[i + 1].Z - ptsList[i].Z) * (ptsList[i + 1].Z - ptsList[i].Z),4);
// pFeature.set_Value(pFeature.Fields.FindField("length"), sLength);
// pFeature.Store();
// }
//}
//开始空间编辑
IWorkspaceEdit pWorkspaceEdit = (IWorkspaceEdit)pWorkspace;
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.StartEditOperation();
IFeatureBuffer pFeatureBuffer = pFeatureClass.CreateFeatureBuffer();
IFeatureCursor pFeatureCursor;
//开始插入新的实体对象
for (int i = 0; i < lineList.Count; i++)
{
IGeometry geometry = lineList[i];
pFeatureCursor = pFeatureClass.Insert(true);
pFeatureBuffer.Shape = geometry;
double sLength = Math.Round((ptsList[i + 1].X - ptsList[i].X) * (ptsList[i + 1].X - ptsList[i].X) + (ptsList[i + 1].Y - ptsList[i].Y) * (ptsList[i + 1].Y - ptsList[i].Y) + (ptsList[i + 1].Z - ptsList[i].Z) * (ptsList[i + 1].Z - ptsList[i].Z), 4);
lineLengthList.Add(sLength);
pFeatureBuffer.set_Value(pFeatureBuffer.Fields.FindField("length"), sLength);
if (sLength > System.Convert.ToSingle(textBoxX4.Text.ToString()))
{
pFeatureBuffer.set_Value(pFeatureBuffer.Fields.FindField("质量"), "坏点");
}
else
{
pFeatureBuffer.set_Value(pFeatureBuffer.Fields.FindField("质量"), "好点");
}
object featureOID = pFeatureCursor.InsertFeature(pFeatureBuffer);
//保存实体
pFeatureCursor.Flush();
//结束空间编辑
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
System.Runtime.InteropServices.Marshal.ReleaseComObject(pFeatureCursor);
}
}
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>
/// 为要素添填充属性
/// </summary>
/// <param name="featureBuffer">要素缓存</param>
/// <param name="feature">待填充的要素</param>
private static void AddFields(IFeatureBuffer featureBuffer, IFeature feature)
{
IRowBuffer rowBuffer = (IRowBuffer)featureBuffer;
IFields fieldsNew = rowBuffer.Fields;
int i;
int intFieldIndex;
IFields fields = feature.Fields;
IField field;
for (i = 0; i < fieldsNew.FieldCount; i++)
{
field = fieldsNew.get_Field(i);
// if (field.Editable == true && (field.Type != esriFieldType.esriFieldTypeGeometry) && (field.Type != esriFieldType.esriFieldTypeOID)
// && (field.Name != "SHAPE_Length") && (field.Name != "SHAPE_Area"))
if (field.Editable == true)
{
intFieldIndex = feature.Fields.FindField(field.Name);
if (intFieldIndex != -1)
{
featureBuffer.set_Value(i, feature.get_Value(intFieldIndex));
}
}
}
}
/// <summary>
/// 使用游标插入要素
/// </summary>
/// <param name="selectionLayer">旧图层</param>
/// <param name="newFeatureClass">新要素集合</param>
/// <param name="fidValue">FID值</param>
/// <param name="selectFieldName">选中字段名称</param>
private static void InsertFeaturesUsingCursor(IFeatureLayer selectionLayer, IFeatureClass newFeatureClass,
Dictionary <string, int> fidValue, List <string> selectFieldName)
{
IFeatureCursor featureCursor = selectionLayer.FeatureClass.Search(null, false);
IFeature oldFeature = featureCursor.NextFeature();
IFeatureCursor insertCursor = newFeatureClass.Insert(true);
while (oldFeature != null)
{
//判断当前要素FID是否在FID集合中，在的话，则赋值给新图层
if (fidValue.ContainsKey(oldFeature.Value[0].ToString()))
{
// Create a feature buffer.
IFeatureBuffer featureBuffer = newFeatureClass.CreateFeatureBuffer();
for (int i = 0; i < featureBuffer.Fields.FieldCount; i++)
{
IField field = featureBuffer.Fields.Field[i];
//字段是选中且可编辑的
if (selectFieldName.Contains(field.Name) && field.Editable)
{
featureBuffer.set_Value(i, oldFeature.Value[i]); //字段赋值
}
}
insertCursor.InsertFeature(featureBuffer);
// Flush the buffer to the geodatabase.
insertCursor.Flush();
}
oldFeature = featureCursor.NextFeature(); //游标移动
}
}
/// <summary>
/// 创建标准要素类
/// </summary>
/// <param name="sourceFeatureClass">原要素类</param>
/// <param name="target_FeatureClass">标准要素类</param>
/// <param name="contrastTable">字段对照表，二维数组</param>
/// <returns>返回创建的标准要素类</returns>
public IFeatureClass CreateStandardFeatureClass(IFeatureClass sourceFeatureClass, IFeatureClass target_FeatureClass
, string[,] contrastTable)
{
IFeature pFeature;
IFeatureCursor sourceCursor = sourceFeatureClass.Search(null, false);
//用IFeatureBuffer提高运算速度
IFeatureBuffer pFeaBuffer = null;
IFeatureCursor targetCursor = target_FeatureClass.Insert(true);
while ((pFeature = sourceCursor.NextFeature()) != null)
{
pFeaBuffer = target_FeatureClass.CreateFeatureBuffer();
pFeaBuffer.Shape = pFeature.Shape;
for (int i = 0; i < contrastTable.Length / 2; i++)
{
pFeaBuffer.set_Value(target_FeatureClass.FindField(contrastTable[i, 0]), pFeature.Value[sourceFeatureClass.Fields.FindField(contrastTable[i, 1])]);
}
targetCursor.InsertFeature(pFeaBuffer);
}
targetCursor.Flush();
//运用IfeatureBuffer和IfeatureCursor时需要手动释放非托管对象
System.Runtime.InteropServices.Marshal.ReleaseComObject(sourceCursor);
System.Runtime.InteropServices.Marshal.ReleaseComObject(pFeaBuffer);
System.Runtime.InteropServices.Marshal.ReleaseComObject(targetCursor);
return(target_FeatureClass);
}
//step.3 遍历待复制的要素类，复制图形和属性并改变图形的坐标系
/// <summary>
/// 遍历待复制的要素类，复制图形和属性并改变图形的坐标系
/// </summary>
/// <param name="fromFeatureClass">待复制的要素类</param>
/// <param name="toFeatureClass">目标要素类</param>
private void featureClassTransSpatialRef(IFeatureClass fromFeatureClass, IFeatureClass toFeatureClass)
{
IFeature pFeature;
IGeometry2 pGeometry;
IFeatureCursor toCursor = toFeatureClass.Insert(true);
int FeatureCount = fromFeatureClass.FeatureCount(null);
for (int i = 0; i < FeatureCount; i++)
{
pFeature = fromFeatureClass.GetFeature(i);
pGeometry = pFeature.Shape as IGeometry2;
IZAware pZAware = pGeometry as IZAware;
pZAware.ZAware = true;
pGeometry.ProjectEx(spatialRefTo, esriTransformDirection.esriTransformForward, geoTransformation, false, 0, 0);
IFeatureBuffer pFeaBuffer = toFeatureClass.CreateFeatureBuffer();
pFeaBuffer.Shape = pGeometry;
for (int j = 2; j < fromFeatureClass.Fields.FieldCount; j++)
{
try
{
pFeaBuffer.set_Value(j, pFeature.Value[fromFeatureClass.FindField(toFeatureClass.Fields.Field[j].Name)]);
}
catch
{
continue;
}
}
toCursor.InsertFeature(pFeaBuffer);
toCursor.Flush();
}
}
/// <summary>
/// 复制featureclass图形和属性的方法
/// </summary>
/// <param name="name">待创建要素类的名称</param>
/// <param name="target_FeatureClass">需要写入图形和属性的空要素</param>
/// <param name="CADFeatureClass">需要复制的CAD要素类</param>
public void CreateFeatureClassByAtt(string name, IFeatureClass target_FeatureClass, IFeatureClass CADFeatureClass)
{
List <string> AttList = new List <string>();
IQueryFilter pQueryFilter = new QueryFilterClass();
IFeatureCursor pFeaCursor;
IFeature pFeature;
IFeatureBuffer pFeaBuffer = null;
AttList = getUniqueValue(CADFeatureClass, "Layer");
pQueryFilter.WhereClause = "Layer = '" + name.Substring(name.IndexOf('-') + 1) + "'";
pFeaCursor = CADFeatureClass.Search(pQueryFilter, false);
//用IFeatureBuffer提高运算速度
IFeatureCursor targetCursor = target_FeatureClass.Insert(true);
while ((pFeature = pFeaCursor.NextFeature()) != null)
{
pFeaBuffer = target_FeatureClass.CreateFeatureBuffer();
IGeoDataset pGeoDataset = pFeature.Class as IGeoDataset;
pFeaBuffer.Shape = pFeature.Shape;
for (int j = 2; j < CADFeatureClass.Fields.FieldCount; j++)
{
try
{
pFeaBuffer.set_Value(j, pFeature.Value[CADFeatureClass.FindField(target_FeatureClass.Fields.Field[j].Name)]);
}catch
{
continue;
}
}
targetCursor.InsertFeature(pFeaBuffer);
targetCursor.Flush();
}
}
public void ExecuteSpatialInsert(IFeatureClass pFeatureClass, IGeometry geometry, string[] columnNames, object[] insertValues)
{
try
{
//创建一个插入的游标
IFeatureCursor featureCursorInsert = pFeatureClass.Insert(true);
//创建要插入的缓冲对象
IFeatureBuffer featureBufferInsert = pFeatureClass.CreateFeatureBuffer();
// 给Shape字段赋值
featureBufferInsert.Shape = geometry;
// 根据字段名称和值，给属性表赋值
for (int columnCounter = 0; columnCounter < columnNames.Length; columnCounter++)
{
string columnName = columnNames.GetValue(columnCounter).ToString();
int fieldPosition = featureBufferInsert.Fields.FindField(columnName);
object insertValue = insertValues.GetValue(columnCounter);
featureBufferInsert.set_Value(fieldPosition, insertValue);
}
//保存到数据库中，看是否要扩到try-catch中
featureCursorInsert.InsertFeature(featureBufferInsert);
featureCursorInsert.Flush();
}
catch (Exception ex)
{
MessageBox.Show("保存图形数据时出错: " + ex.Message, "错误！", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
//函数号：
//函数名：LoadRasterToCatalogDatabase
//函数功能：Raster导入Database
//参数：pWorkspace：数据库，pWorkspace可以是Access 或者SDE
// strCata：Catalog名称
// pRasterDs：需要入库的Rasterdataset
//备注：insert a raster dataset with given path and file name to an existing raster catalog
public void LoadRasterToCatalogDatabase(IWorkspace pWorkspace, string strCata, IRasterDataset pRasterDs, string name)
{
//QI IRasterWorkspaceEx to IWorkspace
IRasterWorkspaceEx pRasWKS = pWorkspace as IRasterWorkspaceEx;
//Open raster catalog
//IRasterCatalog相当于一个FeatureClass（表），表中的每一个记录可以存放Raster
IRasterCatalog pInCatalog = pRasWKS.OpenRasterCatalog(strCata);
// get raster field index
int iRaster = pInCatalog.RasterFieldIndex;
// QI IFeatureClass for inserting
IFeatureClass pFeatureClass = pInCatalog as IFeatureClass;
// get insert cursor
IFeatureCursor pCursor = pFeatureClass.Insert(false);
// create raster value from raster dataset with default storagedef
IRasterValue pRasterValue = new RasterValueClass();
pRasterValue.RasterDataset = pRasterDs;
pRasterValue.RasterStorageDef = new RasterStorageDefClass();
pRasterValue.RasterDatasetName.NameString = name;
//这里可以设置新的RasterStorageDef
// insert the rastervalue ' it will update name, metadata and geometry field
IFeatureBuffer pRow = pFeatureClass.CreateFeatureBuffer();
pRow.set_Value(iRaster, pRasterValue);
pCursor.InsertFeature(pRow);
}
private void InsertFeature(IFeatureCursor inCurr,
IFeatureBuffer inBuff,
IFeature origF,
IGeometry inGeo)
{
mLog.Debug("inside insert feature");
IField tmpField;
IFields fieldColl;
//object Missing = Type.Missing;
fieldColl = origF.Fields;
mLog.Debug("this feature has " + fieldColl.FieldCount.ToString() + " fields to work with");
for (int i = 0; i < fieldColl.FieldCount; i++)
{
tmpField = fieldColl.get_Field(i);
mLog.Debug("this field is " + tmpField.Name);
mLog.Debug("this field type is " + tmpField.VarType.ToString());
if (tmpField.Type != esriFieldType.esriFieldTypeGeometry &&
tmpField.Type != esriFieldType.esriFieldTypeOID &&
tmpField.Editable)
{
mLog.Debug(inBuff.get_Value(i).ToString());
mLog.Debug("seting the value to " + origF.get_Value(i));
inBuff.set_Value(i, origF.get_Value(i));
}
}
inBuff.Shape = inGeo;
inCurr.InsertFeature(inBuff);
inCurr.Flush();
}
//不剪裁输出forShp
public static void notcutExportShp(IFeatureCursor pCursor, IFeatureClass pToFeatureClass, int featurecount)
{
progressStep.Minimum = 0;
progressStep.Maximum = featurecount;
progressStep.Step = 1;
IFeature pFeature = pCursor.NextFeature();
IFeatureCursor pFeatureCursor = pToFeatureClass.Insert(true);
int iCount = 0;
while (pFeature != null)
{
IFeatureBuffer pFeatureBuffer = pToFeatureClass.CreateFeatureBuffer();
for (int i = 0; i < pFeature.Fields.FieldCount; i++)
{
//string sFieldName = pFeature.Fields.get_Field(i).Name;
//int iIndex = pFeatureBuffer.Fields.FindField(toShpField[sFieldName]);
string sFieldName = pFeature.Fields.get_Field(i).Name;
int iIndex = -1;
if (m_DicFields.Keys.Contains(sFieldName))
{
iIndex = pFeatureBuffer.Fields.FindField(m_DicFields[sFieldName]);
}
else
{
iIndex = pFeatureBuffer.Fields.FindField(sFieldName);
}
try
{
if ((iIndex > -1) && (pFeatureBuffer.Fields.get_Field(iIndex).Editable == true))
{
pFeatureBuffer.set_Value(iIndex, pFeature.get_Value(i));
}
}
catch
{ }
}
pFeatureBuffer.Shape = pFeature.ShapeCopy;
pFeatureCursor.InsertFeature(pFeatureBuffer);
if (iCount == 500)
{
pFeatureCursor.Flush();
iCount = 0;
}
iCount++;
progressStep.PerformStep();
pFeature = pCursor.NextFeature();
}
if (iCount > 0)
{
pFeatureCursor.Flush();
}
System.Runtime.InteropServices.Marshal.ReleaseComObject(pFeatureCursor);
pFeatureCursor = null;
}
private void processFieldMapping(IFeature sourceFeature, IFeatureBuffer targetFeatureBuffer)
{
if ((sourceFeature == null) || (targetFeatureBuffer == null))
{
return;
}
try
{
foreach (string outputFieldName in OutputFieldToInputField.Keys)
{
string inputFieldName = OutputFieldToInputField[outputFieldName];
if (!String.IsNullOrEmpty(outputFieldName) && !String.IsNullOrEmpty(inputFieldName))
{
int sourceIndex = sourceFeature.Fields.FindField(inputFieldName);
int targetIndex = targetFeatureBuffer.Fields.FindField(outputFieldName);
if (sourceIndex >= 0 && targetIndex >= 0)
{
IField sourceField = sourceFeature.Fields.get_Field(sourceIndex);
object sourceValue = sourceFeature.get_Value(sourceIndex);
if (sourceValue == null)
{
continue;
}
if (sourceField.Type == esriFieldType.esriFieldTypeString)
{
if (String.IsNullOrEmpty(sourceValue as string))
{
continue;
}
}
IField targetField = targetFeatureBuffer.Fields.get_Field(targetIndex);
try
{
if (targetField.Editable)
{
targetFeatureBuffer.set_Value(targetIndex, sourceValue);
}
else
{
System.Diagnostics.Debug.WriteLine("Field: " + targetField.Name + " not editable.");
}
}
catch (Exception ex2)
{
Console.WriteLine(ex2);
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
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();
}
}
/// <summary>
/// 获取最后生成的照片点图层
/// </summary>
/// <returns></returns>
public ILayer GetPhotosLayer()
{
IFeatureClass featureclass = CreateFeatureClass();
IFeatureCursor featureCursor = featureclass.Insert(true);
//遍历照片链表 以创建缓存的形式插入数据
foreach (var p in PhotoList)
{
IPoint pPoint = new PointClass();
//坐标转换
var t = CoordinateUtils.gcj02_To_Wgs84(p.latitude, p.longtitude);
pPoint.PutCoords(t.longtitude, t.latitude);
pPoint.SpatialReference = mainMapControl.SpatialReference;
pPoint.Project(mainMapControl.SpatialReference);
IFeatureBuffer featureBuffer = featureclass.CreateFeatureBuffer();
featureBuffer.Shape = pPoint;
featureBuffer.set_Value(featureBuffer.Fields.FindField("Name"), p.name);
featureBuffer.set_Value(featureBuffer.Fields.FindField("Latitude"), p.latitude);
featureBuffer.set_Value(featureBuffer.Fields.FindField("Longtitude"), p.longtitude);
featureBuffer.set_Value(featureBuffer.Fields.FindField("OSSpath"), p.osspath);
featureCursor.InsertFeature(featureBuffer);
}
featureCursor.Flush();
//创建图层
IFeatureLayer pFeaturelayer = new FeatureLayerClass();
pFeaturelayer.FeatureClass = featureclass;
pFeaturelayer.Name = "特征地物照片点";
//修饰该图层
ISimpleMarkerSymbol pMarkerSymbol = new SimpleMarkerSymbol();
pMarkerSymbol.Style = esriSimpleMarkerStyle.esriSMSSquare;
var pRgbColor = ColorUtils.GetRgbColor(186, 114, 208);
pMarkerSymbol.Color = pRgbColor;
ISimpleRenderer pSimpleRenderer = new SimpleRendererClass();
pSimpleRenderer.Symbol = (ISymbol)pMarkerSymbol;
(pFeaturelayer as IGeoFeatureLayer).Renderer = pSimpleRenderer as IFeatureRenderer;
return(pFeaturelayer as ILayer);
}
private void CopyFeatureClassData(IFeatureClass sourceFeatureClass, IFeatureClass targetFeatureClass, IDictionary <int, int> filedIndexDictionary)
{
errorRowCount = 0;
using (var comReleaser = new ComReleaser())
{
IFeatureCursor sourceFeatureCursor = sourceFeatureClass.Search(null, false);
IFeatureCursor targetFeatureCursor = targetFeatureClass.Insert(true);
comReleaser.ManageLifetime(sourceFeatureCursor);
comReleaser.ManageLifetime(targetFeatureCursor);
List <int> targeFieldIndexs = filedIndexDictionary.Keys.ToList();
int fieldsLen = targeFieldIndexs.Count;
IFeature sourceFeature = sourceFeatureCursor.NextFeature();
var count = 0;
while (sourceFeature != null)
{
try
{
//错误：Geometry cannot have Z values 处理
IGeometry geometry = sourceFeature.ShapeCopy;
IZAware zAware = geometry as IZAware;
if (zAware != null && zAware.ZAware == true)
{
zAware.ZAware = false;
}
IFeatureBuffer targetFatureBuffer = targetFeatureClass.CreateFeatureBuffer();
targetFatureBuffer.Shape = geometry;//sourceFeature.ShapeCopy;
for (int i = 0; i < fieldsLen; i++)
{
var targetIndex = targeFieldIndexs[i];
int sourceIndex = filedIndexDictionary[targeFieldIndexs[i]];
var value = sourceFeature.get_Value(sourceIndex);
targetFatureBuffer.set_Value(targetIndex, value);
}
targetFeatureCursor.InsertFeature(targetFatureBuffer);
count++;
if (count == 1000)
{
targetFeatureCursor.Flush();
count = 0;
}
}
catch (Exception ex)
{
errorRowCount++;
var message = "字段赋值错误";
//LoggingManager.GetLogger(GetType()).Error(message, ex);
}
sourceFeature = sourceFeatureCursor.NextFeature();
}
targetFeatureCursor.Flush();
}
}
public static void CleanUpSignpostFeatureValues(IFeatureBuffer featureBuffer, int lastValidBranchNum, int lastValidTowardNum,
int[] outBranchXFI, int[] outBranchXDirFI, int[] outBranchXLngFI,
int[] outTowardXFI, int[] outTowardXLngFI)
{
// set unused sequence number values to null (our row buffer may still
// have junk at the end)
for (int i = lastValidBranchNum + 1; i < SignpostUtilities.MaxBranchCount; i++)
{
featureBuffer.set_Value(outBranchXFI[i], null);
featureBuffer.set_Value(outBranchXDirFI[i], null);
featureBuffer.set_Value(outBranchXLngFI[i], null);
}
for (int i = lastValidTowardNum + 1; i < SignpostUtilities.MaxBranchCount; i++)
{
featureBuffer.set_Value(outTowardXFI[i], null);
featureBuffer.set_Value(outTowardXLngFI[i], null);
}
}
public static void CleanUpSignpostFeatureValues(IFeatureBuffer featureBuffer, int lastValidBranchNum, int lastValidTowardNum,
int[] outBranchXFI, int[] outBranchXDirFI, int[] outBranchXLngFI,
int[] outTowardXFI, int[] outTowardXLngFI)
{
// set unused sequence number values to null (our row buffer may still
// have junk at the end)
for (int i = lastValidBranchNum + 1; i < SignpostUtilities.MaxBranchCount; i++)
{
featureBuffer.set_Value(outBranchXFI[i], null);
featureBuffer.set_Value(outBranchXDirFI[i], null);
featureBuffer.set_Value(outBranchXLngFI[i], null);
}
for (int i = lastValidTowardNum + 1; i < SignpostUtilities.MaxBranchCount; i++)
{
featureBuffer.set_Value(outTowardXFI[i], null);
featureBuffer.set_Value(outTowardXLngFI[i], null);
}
}
private static void SetFeatureBufferValue(IFeatureBuffer featureBuffer, Dictionary <int, Clazz> dic, object obj)
{
Dictionary <int, Clazz> .KeyCollection keys = dic.Keys;
foreach (int current in keys)
{
Clazz clazz = dic[current];
object value = clazz.GetMethodInfo.Invoke(obj, null);
if (value != null)
{
featureBuffer.set_Value(current, value);
}
}
}
public override bool AddFeatures(string featureClassName, List <MyFeature> features, int extraFieldCount)
{
if (this.featureClassMap.ContainsKey(featureClassName) && null != this.featureClassMap[featureClassName] && null != features && features.Count > 0)
{
IFeatureBuffer featureBuffer = this.featureClassMap[featureClassName].CreateFeatureBuffer();
IFeatureCursor featureCursor = this.featureClassMap[featureClassName].Insert(true);
try
{
int count = 0;
foreach (var feature in features)
{
if (null != feature && feature.GeometryType == this.featureClassMap[featureClassName].ShapeType)
{
featureBuffer.Shape = feature.Geometry;
/*
* Index for extra fields start from 2
* Index 0 is OID
* Index 1 is geometry
*/
if (extraFieldCount > 0)
{
if (null == feature.Attributes && extraFieldCount != feature.Attributes.Count)
{
throw new ArgumentException("Extra field doesn't exist or it's count doesn't match with the specified value in the method's argument.");
}
for (int i = 0, fldIdx = 2; i < extraFieldCount; ++i, ++fldIdx)
{
featureBuffer.set_Value(fldIdx, feature.Attributes[i]);
}
}
if (null != featureCursor.InsertFeature(featureBuffer))
{
++count;
}
}
else
{
throw new ArgumentException("Feature is null or its geometry type doesn't match feature class specified.");
}
}
featureCursor.Flush();
return(count == features.Count);
}
finally
{
this.releaseCOMObj(featureCursor);
}
}
return(false);
}
private IFeatureClass AddFeatureToFeatureClass(IFeatureClass pFeatureClass, IFeature pFeature)
{
IFeatureCursor pFeatureCursor = pFeatureClass.Insert(true);
IFeatureBuffer pFeatureBuffer = pFeatureClass.CreateFeatureBuffer();
IFields pFields = pFeatureClass.Fields;
for (int i = 1; i <= pFeature.Fields.FieldCount - 1; i++)
{
IField pField = pFields.get_Field(i);
if (pField.Type == esriFieldType.esriFieldTypeGeometry)
{
pFeatureBuffer.set_Value(i, pFeature.ShapeCopy);
}
else
{ // try// {
switch (pField.Type)
{
case esriFieldType.esriFieldTypeInteger:
pFeatureBuffer.set_Value(i, Convert.ToInt32(pFeature.get_Value(i)));
break;
case esriFieldType.esriFieldTypeDouble:
pFeatureBuffer.set_Value(i, Convert.ToDouble(pFeature.get_Value(i)));
break;
case esriFieldType.esriFieldTypeString:
pFeatureBuffer.set_Value(i, Convert.ToString(pFeature.get_Value(i)));
break;
default:
pFeatureBuffer.set_Value(i, Convert.ToDouble(pFeature.get_Value(i)));
break; // }
} // catch (Exception e)// { // }
}
}
pFeatureCursor.InsertFeature(pFeatureBuffer);
return(pFeatureClass);
}
static public void CreateFeaturePt(IFeatureLayer featurePtLyr, int terlkFid, IPoint newFpt, int location, int sMark, double c)
{
int elev = featurePtLyr.FeatureClass.FindField("Elev");
int terlkAtFid = featurePtLyr.FeatureClass.FindField("TerlkFID");
int whereAtCou = featurePtLyr.FeatureClass.FindField("WhereAtCou");
int mark = featurePtLyr.FeatureClass.FindField("Mark");
int cur = featurePtLyr.FeatureClass.FindField("Curve");
IFeatureBuffer featureBuffer = featurePtLyr.FeatureClass.CreateFeatureBuffer();
IFeatureCursor featureCursor = featurePtLyr.FeatureClass.Insert(true);
IZAware pZAware = (IZAware)newFpt;
pZAware.ZAware = true;
featureBuffer.Shape = newFpt;
featureBuffer.set_Value(terlkAtFid, terlkFid);
featureBuffer.set_Value(elev, Math.Round(newFpt.Z, 2));
featureBuffer.set_Value(whereAtCou, location);
featureBuffer.set_Value(mark, sMark);
featureBuffer.set_Value(cur, c);
featureCursor.InsertFeature(featureBuffer);
featureCursor.Flush();
System.Runtime.InteropServices.Marshal.ReleaseComObject(featureCursor);
}
public static void ToRasterCatalog(IList ilist_0, IFeatureClass ifeatureClass_0)
{
IFeatureCursor o = ifeatureClass_0.Insert(false);
IRasterCatalog catalog = ifeatureClass_0 as IRasterCatalog;
for (int i = 0; i < ilist_0.Count; i++)
{
IRasterDataset dataset = (ilist_0[i] as IName).Open() as IRasterDataset;
IFeatureBuffer buffer = ifeatureClass_0.CreateFeatureBuffer();
buffer.set_Value(catalog.RasterFieldIndex, createRasterValue(dataset));
o.InsertFeature(buffer);
}
o.Flush();
ComReleaser.ReleaseCOMObject(o);
}
public void CopyFeatureField(IFeature pFt, IFeatureBuffer pFtNew)
{
IFields pFlds = pFt.Fields;
IFields pFldsNew = pFtNew.Fields;
int nCount = pFlds.FieldCount;
for (int i = 0; i < nCount; i++)
{
if (pFlds.get_Field(i).Type != esriFieldType.esriFieldTypeGeometry &&
pFlds.get_Field(i).Type != esriFieldType.esriFieldTypeOID)
{
pFtNew.set_Value(i, (object)pFt.get_Value(i));
}
}
}
static public void CreateStructPly(IFeatureLayer featurePtLyr, IPolyline structPly, int cd, bool isValOrRidge)
{
int mark = featurePtLyr.FeatureClass.FindField("Mark");
int code = featurePtLyr.FeatureClass.FindField("Code");
IFeatureBuffer featureBuffer = featurePtLyr.FeatureClass.CreateFeatureBuffer();
IFeatureCursor featureCursor = featurePtLyr.FeatureClass.Insert(true);
IZAware pZAware = (IZAware)structPly;
pZAware.ZAware = true;
featureBuffer.Shape = structPly;
if (isValOrRidge == true)
{
featureBuffer.set_Value(mark, -1);
featureBuffer.set_Value(code, cd);
}
else
{
featureBuffer.set_Value(mark, 1);
featureBuffer.set_Value(code, cd);
}
featureCursor.InsertFeature(featureBuffer);
featureCursor.Flush();
System.Runtime.InteropServices.Marshal.ReleaseComObject(featureCursor);
}
public void InsertFeaturesUsingCursor(IFeatureClass sourceFeatureClass, IFeatureClass targetFeatureClass)
{
using (ComReleaser comReleaser = new ComReleaser())
{
// Create a feature buffer.
IFeatureBuffer featureBuffer = targetFeatureClass.CreateFeatureBuffer();
comReleaser.ManageLifetime(featureBuffer);
// Create an insert cursor.
IFeatureCursor insertCursor = targetFeatureClass.Insert(true);
comReleaser.ManageLifetime(insertCursor);
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = queryClause;
IFeatureCursor cursor = sourceFeatureClass.Search(queryFilter, true);
IFeature sourceFeature = cursor.NextFeature();
while (sourceFeature != null)
{
//如果是线或面要素类需要执行下Simplify，这里用的点要素类，不做验证了
featureBuffer.Shape = sourceFeature.ShapeCopy;
for (int i = 0; i < sourceFeature.Fields.FieldCount; i++)
{
IField field = sourceFeature.Fields.get_Field(i);
if (field.Type != esriFieldType.esriFieldTypeOID && field.Type != esriFieldType.esriFieldTypeGeometry && field.Type != esriFieldType.esriFieldTypeGlobalID && field.Type != esriFieldType.esriFieldTypeGUID)
{
string fieldName = field.Name;
int index = featureBuffer.Fields.FindField(fieldName);
if (index > -1 && fieldName != "Shape_Length" && fieldName != "Shape_Area")
{
featureBuffer.set_Value(index, sourceFeature.get_Value(i));
}
}
}
insertCursor.InsertFeature(featureBuffer);
sourceFeature = cursor.NextFeature();
}
// Flush the buffer to the geodatabase.
insertCursor.Flush();
ComReleaser.ReleaseCOMObject(cursor);
}
IFeatureClassManage targetFeatureClassManage = targetFeatureClass as IFeatureClassManage;
targetFeatureClassManage.UpdateExtent();
}
private static void GetFacilityFeature(IFeatureClass featureClass1, IFeatureClass featureClass2, int[] oidList)
{
foreach (int oid in oidList)
{
if (oid == 0)
{
break;
}
IFeature pfeature = featureClass1.GetFeature(oid) as IFeature;
//Create the Feature Buffer
IFeatureBuffer featureBuffer = featureClass2.CreateFeatureBuffer();
//Create insert Feature Cursor using buffering = true.
IFeatureCursor featureCursor = featureClass2.Insert(true);
object featureOID;
//With a feature buffer you have the ability to set the attribute for a specific field to be
//the same for all features added to the buffer.
//featureBuffer.set_Value(featureBuffer.Fields.FindField("InstalledBy "), "K Johnston ");
for (int i = 2; i < featureBuffer.Fields.FieldCount; i++)
{
featureBuffer.set_Value(i, pfeature.get_Value(i));
}
featureBuffer.Shape = pfeature.ShapeCopy;
//int index = featureBuffer.Fields.FindField("ID");
//featureBuffer.set_Value(index, "4281");
//Here you can set the featurebuffers 's shape by setting the featureBuffer.Shape
//to a geomerty that matched the featureclasses.
//Insert the feature into the feature cursor
featureOID = featureCursor.InsertFeature(featureBuffer);
//Calling flush allows you to handle any errors at a known time rather then on the cursor destruction.
featureCursor.Flush();
//Release the Cursor
System.Runtime.InteropServices.Marshal.ReleaseComObject(featureCursor);
}
}
private void processSidc(IRepresentationClass repClass, IFeatureBuffer targetFeatureBuffer, string sidc)
{
if ((symbolCreator == null) || (repClass == null) || (targetFeatureBuffer == null))
{
Console.WriteLine("Failed to initialize - could not create RepRule for SIDC: " + sidc);
return;
}
if (!symbolCreator.Initialized)
{
Console.WriteLine("SymbolCreator is not initialized - can't look up SIDCs/symbols");
return;
}
int ruleIdIndex = targetFeatureBuffer.Fields.FindField(MilitaryFeatureClassHelper.RULE_FIELD_NAME1);
if (ruleIdIndex < 0) // *2* different rule field names, need to check for both
{
ruleIdIndex = targetFeatureBuffer.Fields.FindField(MilitaryFeatureClassHelper.RULE_FIELD_NAME2);
}
if (ruleIdIndex < 0)
{
Console.WriteLine("Could not find field:{0}/{1} in output",
MilitaryFeatureClassHelper.RULE_FIELD_NAME1,
MilitaryFeatureClassHelper.RULE_FIELD_NAME2);
return;
}
int repRuleId = getRepRuleIdForSidc(repClass, sidc);
if (repRuleId < 0)
{
repRuleId = addRepRuleIdForSidc(repClass, sidc);
}
if (repRuleId < 0)
{
Console.WriteLine("Could not create RepRule for SIDC: " + sidc);
return;
}
object o = repRuleId;
targetFeatureBuffer.set_Value(ruleIdIndex, o);
}
private static void CopyFields(IFeature from, IFeatureBuffer to)
{
for (var i = 0; i < to.Fields.FieldCount; i++)
{
var fld = to.Fields.Field[i];
var fldName = fld.Name.ToUpper();
if (ReservedFields.Contains(fldName) == false)
{
var idx = from.Fields.FindField(fld.Name);
if (idx > -1)
{
var val = from.get_Value(idx);
if (val != null)
{
Console.WriteLine(string.Format("Fieldname：{0}", fldName));
Console.WriteLine(string.Format("Val:{0}", val));
to.set_Value(i, val);
Console.WriteLine(string.Format("i:{0}", i));
}
}
}
}
}
private static void CopyFields(IFeature from, IFeatureBuffer to)
{
for (var i = 0; i < to.Fields.FieldCount; i++)
{
var fld = from.Fields.Field[i];
var fldName = fld.Name.ToUpper();
if (ReservedFields.Contains(fldName) == false)
{
var idx = from.Fields.FindField(fld.Name);
if (idx > -1)
{
to.set_Value(i, from.get_Value(idx));
}
}
}
}
private void processSidc(IRepresentationClass repClass, IFeatureBuffer targetFeatureBuffer, string sidc)
{
if ((symbolCreator == null) || (repClass == null) || (targetFeatureBuffer == null))
{
Console.WriteLine("Failed to initialize - could not create RepRule for SIDC: " + sidc);
return;
}
if (!symbolCreator.Initialized)
{
Console.WriteLine("SymbolCreator is not initialized - can't look up SIDCs/symbols");
return;
}
int ruleIdIndex = targetFeatureBuffer.Fields.FindField(MilitaryFeatureClassHelper.RULE_FIELD_NAME1);
if (ruleIdIndex < 0) // *2* different rule field names, need to check for both
ruleIdIndex = targetFeatureBuffer.Fields.FindField(MilitaryFeatureClassHelper.RULE_FIELD_NAME2);
if (ruleIdIndex < 0)
{
Console.WriteLine("Could not find field:{0}/{1} in output",
MilitaryFeatureClassHelper.RULE_FIELD_NAME1,
MilitaryFeatureClassHelper.RULE_FIELD_NAME2);
return;
}
int repRuleId = getRepRuleIdForSidc(repClass, sidc);
if (repRuleId < 0)
repRuleId = addRepRuleIdForSidc(repClass, sidc);
if (repRuleId < 0)
{
Console.WriteLine("Could not create RepRule for SIDC: " + sidc);
return;
}
object o = repRuleId;
targetFeatureBuffer.set_Value(ruleIdIndex, o);
}
private void processMiscellaneousFields(IFeatureBuffer targetFeatureBuffer, string sidc)
{
if ((symbolCreator == null) || (targetFeatureBuffer == null))
return;
// Set required field UniqueDesignation if empty
int indexUD = targetFeatureBuffer.Fields.FindField(MilitaryFeatureClassHelper.UNIQUE_ID_FIELD_NAME);
if (indexUD >= 0)
{
object oUD = targetFeatureBuffer.get_Value(indexUD);
string s = oUD.ToString();
// if its null or hasn't changed, set it
if ((lastUniqueDesignation == s) || (oUD == null) || (oUD == DBNull.Value) || (s.Length == 0))
{
string newUniqueDesignation = symbolCreator.GetGenericSymbolName(sidc);
// Apparently if you set a string field to a size larger than allowed it throws an exception
// so don't let this happen
IField uidField = targetFeatureBuffer.Fields.get_Field(indexUD);
if (uidField != null)
{
int maxUidLength = uidField.Length;
if (newUniqueDesignation.Length > maxUidLength)
newUniqueDesignation = newUniqueDesignation.Substring(0, maxUidLength);
}
targetFeatureBuffer.set_Value(indexUD, newUniqueDesignation);
lastUniqueDesignation = newUniqueDesignation;
}
}
// Set Echelon field
int indexEch = targetFeatureBuffer.Fields.FindField(MilitaryFeatureClassHelper.ECHELON_FIELD);
if ((indexEch >= 0) && (symbolCreator.HasValidEchelon(sidc)))
{
object oEch = targetFeatureBuffer.get_Value(indexEch);
if ((oEch == DBNull.Value) || (oEch.ToString().Length == 0)) // if it's empty
{
int ech = symbolCreator.GetEchelonOrdinal(sidc);
oEch = (object)ech;
targetFeatureBuffer.set_Value(indexEch, oEch);
lastEchelon = ech;
}
else
{
// if its not empty, it may be because of the previous value/state of the featurebuffer
// so we need to check the case when it hasn't changed
int ech = (int)oEch;
if (ech == lastEchelon)
{
ech = symbolCreator.GetEchelonOrdinal(sidc);
oEch = (object)ech;
targetFeatureBuffer.set_Value(indexEch, oEch);
lastEchelon = ech;
}
}
}
// Set Country Code field
int indexCC = targetFeatureBuffer.Fields.FindField(MilitaryFeatureClassHelper.COUNTRY_FIELD);
if (indexCC >= 0)
{
object oCC = targetFeatureBuffer.get_Value(indexCC);
string s = oCC.ToString();
// if its null or hasn't changed, set it
if ((lastCountryCode == s) || (oCC == null) || (oCC == DBNull.Value) || (s.Length == 0))
{
string countryCode = symbolCreator.GetCountryCode(sidc);
targetFeatureBuffer.set_Value(indexCC, countryCode);
lastCountryCode = countryCode;
}
}
}
private void processFieldMapping(IFeature sourceFeature, IFeatureBuffer targetFeatureBuffer)
{
if ((sourceFeature == null) || (targetFeatureBuffer == null))
return;
try
{
foreach (string outputFieldName in OutputFieldToInputField.Keys)
{
string inputFieldName = OutputFieldToInputField[outputFieldName];
if (!String.IsNullOrEmpty(outputFieldName) && !String.IsNullOrEmpty(inputFieldName))
{
int sourceIndex = sourceFeature.Fields.FindField(inputFieldName);
int targetIndex = targetFeatureBuffer.Fields.FindField(outputFieldName);
if (sourceIndex >= 0 && targetIndex >= 0)
{
IField sourceField = sourceFeature.Fields.get_Field(sourceIndex);
object sourceValue = sourceFeature.get_Value(sourceIndex);
if (sourceValue == null)
{
continue;
}
if (sourceField.Type == esriFieldType.esriFieldTypeString)
{
if (String.IsNullOrEmpty(sourceValue as string))
{
continue;
}
}
IField targetField = targetFeatureBuffer.Fields.get_Field(targetIndex);
try
{
if (targetField.Editable)
{
targetFeatureBuffer.set_Value(targetIndex, sourceValue);
}
else
{
System.Diagnostics.Debug.WriteLine("Field: " + targetField.Name + " not editable.");
}
}
catch (Exception ex2)
{
Console.WriteLine(ex2);
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private static void CopyValues(IFeatureBuffer buff, Dictionary<string, string> values)
{
for (var i = 0; i < buff.Fields.FieldCount; i++)
{
var fld = buff.Fields.Field[i];
if(values.ContainsKey(fld.Name) == false) continue;
var o = values[fld.Name];
if (string.IsNullOrEmpty(o))
{
if(fld.Type == esriFieldType.esriFieldTypeString)
{
buff.set_Value(i, o);
}
else
{
buff.set_Value(i, DBNull.Value);
}
}
else
{
switch (fld.Type)
{
case esriFieldType.esriFieldTypeDate:
buff.set_Value(i, Convert.ToDateTime(o));
break;
case esriFieldType.esriFieldTypeDouble:
buff.set_Value(i, Convert.ToDouble(o));
break;
case esriFieldType.esriFieldTypeInteger:
buff.set_Value(i, Convert.ToInt32(o));
break;
case esriFieldType.esriFieldTypeSingle:
buff.set_Value(i, Convert.ToSingle(o));
break;
case esriFieldType.esriFieldTypeString:
buff.set_Value(i, o.ToString());
break;
default:
throw new NotSupportedException(string.Format("不支持赋值类型'{0}'到字段", fld.Type));
}
}
}
}
void ICopyFeatures.AddFields(IFeatureBuffer featureBuffer, IFeature feature)
{
// Copy the attributes of the orig feature the new feature
IRowBuffer rowBuffer = (IRowBuffer)featureBuffer;
IFields fieldsNew = rowBuffer.Fields;
IFields fields = feature.Fields;
for (int i = 0; i <= fields.FieldCount - 1; i++)
{
IField field = fields.get_Field(i);
if ((field.Type != esriFieldType.esriFieldTypeGeometry) &&
(field.Type != esriFieldType.esriFieldTypeOID))
{
int intFieldIndex = fieldsNew.FindField(field.Name);
if (intFieldIndex != -1)
{
featureBuffer.set_Value(intFieldIndex, feature.get_Value(i));
}
}
}
}
