wangguanjie
/
NDBGJK5.0
4
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
年度变更建库软件5.0版本
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
4 Branches
0 Tags
121 MiB
 
 
Tag: Branch: Tree: wgj
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'wgj'
${ noResults }
NDBGJK5.0/Kingo.Plugins/数据建库/Kingo.Plugin.DLTB_IDG/View/ZLDataModifyView.xaml.cs

2452 lines
127 KiB
Raw Permalink Blame History

using ESRI.ArcGIS.Carto;
using ESRI.ArcGIS.Controls;
using ESRI.ArcGIS.Geodatabase;
using ESRI.ArcGIS.Geometry;
using KGIS.Framework.AE;
using KGIS.Framework.AE.ExtensionMethod;
using KGIS.Framework.Maps;
using KGIS.Framework.Platform;
using KGIS.Framework.Utils;
using KGIS.Framework.Utils.ExtensionMethod;
using KGIS.Framework.Utils.Helper;
using KGIS.Framework.Views;
using Kingo.PluginServiceInterface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Controls;
using UIShell.OSGi;
using KUI.Windows;
using KGIS.Framework.Utils.Interface;
using System.Data;
using KGIS.Framework.DBOperator;
namespace Kingo.Plugin.DLTB_IDG.View
{
/// <summary>
/// 地类增量图斑更新 的交互逻辑
/// </summary>
public partial class ZLDataModifyView : UserControl, IDockPanel2
{
private EngineEditorClass pEditor = null;
private List<IElementInfo> _Elements = null;
private IElementInfo _FeatureInfo = null;
private IFeatureLayer _curDLTBGX_FL = null;
private IFeatureLayer _curDLTBGXGC_FL = null;
private string MaxBSM { get; set; }
public event EventHandler CloseViewHandler;
private int SaveFeatureOID = -1;
private bool IsSave = false;
private ControlsMapRefreshViewCommandClass refresh = new ControlsMapRefreshViewCommandClass();
private Dictionary<string, int> jc_FieldsIndex;
private Dictionary<string, int> gx_FieldsIndex;
private Dictionary<string, int> gxgc_FieldsIndex;
public Dictionary<string, int> TempBSMDic = new Dictionary<string, int>();
public Dictionary<string, int> TempTBBHDic = new Dictionary<string, int>();
/// <summary>
/// 基础地类图斑层
/// </summary>
private IFeatureLayer jcdltb_Layer = null;
private string XZQCode = string.Empty;
IRDBHelper rdbHelper = null;
DataTable dtDict = null;
public ZLDataModifyView(IFeatureLayer GXLayer)
{
InitializeComponent();
Title = "增量更新变更";
this.DockAreas = DockStyle.DockRight | DockStyle.Document;
this.FloatSize = new System.Drawing.Size(400, 800);
this.DefaultArea = DockStyle.DockRight;
this.DockWidth = 400;
this.ShowCloseButton = true;
this.ShowAutoHideButton = true;
InitView();
this.Loaded += (s, e) =>
{
MapsManager.Instance.MapService.OnSelectionChanged += MapService_OnSelectionChanged;
_curDLTBGX_FL = GXLayer;// MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBGX");
_curDLTBGXGC_FL = MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBGXGC");
jcdltb_Layer = MapsManager.Instance.MapService.GetFeatureLayerByLayerName("地类图斑");
XZQCode = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).CODE;
refresh.OnCreate(MapsManager.Instance.MapService.Hook);
pEditor = new EngineEditorClass();
};
}
/// <summary>
/// 构造函数()
/// </summary>
public ZLDataModifyView()
{
refresh = new ControlsMapRefreshViewCommandClass();
}
private void MapService_OnSelectionChanged(object sender, EventArgs e)
{
try
{
ISelectionSet pSelectionSetes = (_curDLTBGX_FL as IFeatureSelection).SelectionSet;//获取图层要素已被选择的
int oid = -1;
if (pSelectionSetes != null && pSelectionSetes.Count == 1)
{
if (IsSave) return;
IEnumIDs enumIDs = pSelectionSetes.IDs;
enumIDs.Reset();
while ((oid = enumIDs.Next()) >= 0)
{
IFeature f = _curDLTBGX_FL.FeatureClass.GetFeature(oid);
_FeatureInfo.BindData(f);
SaveFeatureOID = oid;
btnSave.Visibility = Visibility.Visible;
btnDele.Visibility = Visibility.Collapsed;
break;
}
Marshal.ReleaseComObject(enumIDs);
}
else if (pSelectionSetes != null && pSelectionSetes.Count != 1)
{
oid = -1;
}
if (oid == -1)
{
_FeatureInfo.BindData(_curDLTBGX_FL.FeatureClass.CreateFeatureBuffer() as IFeature);
btnSave.Visibility = Visibility.Collapsed;
btnDele.Visibility = Visibility.Collapsed;
}
}
catch (Exception ex)
{
LogAPI.Debug(ex.Message);
}
}
#region 继承属性
public bool IsShow { get; set; }
public int ShowIndex { get; set; }
public bool ResetSize { get; set; }
public bool AllowEdit { get; set; }
public Guid ID { get; set; }
public DockStyle DockAreas { get; set; }
public System.Drawing.Size FloatSize { get; set; }
public int DockWidth { get; set; }
public int DockHeight { get; set; }
public DockStyle DefaultArea { get; set; }
public bool ShowCloseButton { get; set; }
public bool ShowAutoHideButton { get; set; }
public string Title { get; set; }
public bool IsShowInMap { get; set; }
#endregion
/// <summary>
/// 保存-按钮
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BtnSave_Click(object sender, RoutedEventArgs e)
{
try
{
IsSave = false;
btnSave.IsEnabled = false;
btnDele.IsEnabled = false;
if (pEditor.EditState != esriEngineEditState.esriEngineStateEditing)
{
MessageHelper.ShowTips("请先开启图层编辑！");
return;
}
this.ShowLoading("正在进行增量更新数据准备........", 0, 0);
if (_curDLTBGX_FL == null)
_curDLTBGX_FL = MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBGX");
if (string.IsNullOrWhiteSpace(MaxBSM))
MaxBSM = GetMaxBSM(new List<IFeatureClass>() { _curDLTBGX_FL.FeatureClass, _curDLTBGXGC_FL.FeatureClass, jcdltb_Layer.FeatureClass });
IFeature GX_f = null;
SaveDataBySaveCommand();//执行变更前保存因外部修改
if (SaveFeatureOID != -1)
{
try
{
GX_f = _curDLTBGX_FL.FeatureClass.GetFeature(SaveFeatureOID);
}
catch (Exception)
{
MessageHelper.ShowError("当前数据获取失败，请重新选择数据！");
return;
}
}
else return;
int BSMGXIndex = _curDLTBGX_FL.FeatureClass.FindField("BSM");
ITable tableGC = _curDLTBGXGC_FL.FeatureClass as ITable;
ITable tableGX = _curDLTBGX_FL.FeatureClass as ITable;
if (GX_f != null)
{
if (DataSpecificationCheck(GX_f) == false) return;
}
else
{
MessageHelper.ShowTips("当前图斑获取失败_OID:" + SaveFeatureOID);
return;
}
string GX_BSM = GX_f.Value[BSMGXIndex].ToString().Trim();
IQueryFilter queryFilter = new QueryFilterClass
{
WhereClause = string.Format("BGHTBBSM='{0}'", GX_BSM)
};
#region 图层字段
if (jc_FieldsIndex == null || jc_FieldsIndex.Count == 0)
jc_FieldsIndex = GetFieldsIndex(jcdltb_Layer.FeatureClass.Fields);
if (gx_FieldsIndex == null || gx_FieldsIndex.Count == 0)
gx_FieldsIndex = GetFieldsIndex(_curDLTBGX_FL.FeatureClass.Fields);
if (gxgc_FieldsIndex == null || gxgc_FieldsIndex.Count == 0)
gxgc_FieldsIndex = GetFieldsIndex(_curDLTBGXGC_FL.FeatureClass.Fields);
#endregion
this.UpdateMsg("正在进行增量数据更新........");
queryFilter.WhereClause = string.Format("BSM='{0}'", GX_BSM);
if (tableGX.RowCount(queryFilter) > 1)//存在重复BSM，默认是分割图斑造成
{
IFeatureCursor featureCursorGX = _curDLTBGX_FL.FeatureClass.Update(queryFilter, false);
IFeature featureGX = null;
while ((featureGX = featureCursorGX.NextFeature()) != null)
{
if (featureGX.OID == GX_f.OID)
{
ExeZLDataGeneration(featureGX, jcdltb_Layer, null, _curDLTBGX_FL, _curDLTBGXGC_FL, XZQCode);
}
else
{ //切割的其余部分要重新赋值BSM
string bsmPrefix = MaxBSM.Substring(0, 10);
int MaxNum = Convert.ToInt32(MaxBSM.Substring(9));
MaxBSM = bsmPrefix + (MaxNum + 1).ToString().PadLeft(8, '0');
featureGX.Value[BSMGXIndex] = MaxBSM;
featureGX.Store();
ExeZLDataGeneration(featureGX, jcdltb_Layer, null, _curDLTBGX_FL, _curDLTBGXGC_FL, XZQCode);
}
}
}
else//新增/BSM唯一
{
if (string.IsNullOrWhiteSpace(GX_BSM))//BSM为空，默认为新增图斑
{ //新增图斑重新编BSM
string bsmPrefix = MaxBSM.Substring(0, 10);
int MaxNum = Convert.ToInt32(MaxBSM.Substring(9));
MaxBSM = bsmPrefix + (MaxNum + 1).ToString().PadLeft(8, '0');
GX_f.Value[BSMGXIndex] = MaxBSM;
GX_f.Store();
}
ExeZLDataGeneration(GX_f, jcdltb_Layer, null, _curDLTBGX_FL, _curDLTBGXGC_FL, XZQCode);
}
refresh.OnClick();
this.CloseLoading();
IsSave = true;
MessageHelper.ShowTips("增量数据更新成功！");
}
catch (Exception ex)
{
IsSave = false;
LogAPI.Debug("增量数据更新失败！");
LogAPI.Debug(ex);
this.CloseLoading();
MessageHelper.ShowError("保存失败：" + ex.Message);
SaveFeatureOID = -1;
_FeatureInfo.BindData(_curDLTBGX_FL.FeatureClass.CreateFeatureBuffer() as IFeature);
}
finally
{
#region 注释(调用保存)
#endregion
IsSave = false;
btnSave.IsEnabled = true;
btnDele.IsEnabled = true;
this.CloseLoading();
}
}
//系统保存，避免最终非常规关闭，导致所有修改项保存失败
private ControlsEditingSaveCommandClass saveCmd = null;
private void SaveDataBySaveCommand()
{
if (saveCmd == null)
{
saveCmd = new ControlsEditingSaveCommandClass();
saveCmd.OnCreate(MapsManager.Instance.MapService.Hook);
}
if (saveCmd.Enabled)
{
saveCmd.OnClick();
}
}
public void ExeBatchModifying(IFeatureLayer _curDLTBGX_FL, IQueryFilter queryFilter)
{
try
{
this.ShowLoading("正在进行增量更新数据准备........", 0, 0);
if (_curDLTBGXGC_FL == null)
_curDLTBGXGC_FL = MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBGXGC");
if (jcdltb_Layer == null)
jcdltb_Layer = MapsManager.Instance.MapService.GetFeatureLayerByLayerName("地类图斑");
XZQCode = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).CODE;
refresh.OnCreate(MapsManager.Instance.MapService.Hook);
#region 图层字段
if (jc_FieldsIndex == null || jc_FieldsIndex.Count == 0)
jc_FieldsIndex = GetFieldsIndex(jcdltb_Layer.FeatureClass.Fields);
if (gx_FieldsIndex == null || gx_FieldsIndex.Count == 0)
gx_FieldsIndex = GetFieldsIndex(_curDLTBGX_FL.FeatureClass.Fields);
if (gxgc_FieldsIndex == null || gxgc_FieldsIndex.Count == 0)
gxgc_FieldsIndex = GetFieldsIndex(_curDLTBGXGC_FL.FeatureClass.Fields);
#endregion
if (_curDLTBGX_FL == null)
_curDLTBGX_FL = MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBGX");
if (string.IsNullOrWhiteSpace(MaxBSM))
MaxBSM = GetMaxBSM(new List<IFeatureClass>() { _curDLTBGX_FL.FeatureClass, _curDLTBGXGC_FL.FeatureClass, jcdltb_Layer.FeatureClass });
IFeature GX_f = null;
IFeatureCursor feature = _curDLTBGX_FL.FeatureClass.Update(queryFilter, true);
int BSMGXIndex = _curDLTBGX_FL.FeatureClass.FindField("BSM");
ITable tableGC = _curDLTBGXGC_FL.FeatureClass as ITable;
ITable tableGX = _curDLTBGX_FL.FeatureClass as ITable;
this.UpdateMsg("正在进行增量数据更新........");
while ((GX_f = feature.NextFeature()) != null)
{
string GX_BSM = GX_f.Value[BSMGXIndex].ToString().Trim();
queryFilter.WhereClause = string.Format("BSM='{0}'", GX_BSM);
if (tableGX.RowCount(queryFilter) > 1)//存在重复BSM，默认是分割图斑造成
{
IFeatureCursor featureCursorGX = _curDLTBGX_FL.FeatureClass.Update(queryFilter, false);
IFeature featureGX = null;
while ((featureGX = featureCursorGX.NextFeature()) != null)
{
if (featureGX.OID == GX_f.OID)
{
ExeZLDataGeneration(featureGX, jcdltb_Layer, null, _curDLTBGX_FL, _curDLTBGXGC_FL, XZQCode);
}
else
{ //切割的其余部分要重新赋值BSM
string bsmPrefix = MaxBSM.Substring(0, 10);
int MaxNum = Convert.ToInt32(MaxBSM.Substring(9));
MaxBSM = bsmPrefix + (MaxNum + 1).ToString().PadLeft(8, '0');
featureGX.Value[BSMGXIndex] = MaxBSM;
featureGX.Store();
ExeZLDataGeneration(featureGX, jcdltb_Layer, null, _curDLTBGX_FL, _curDLTBGXGC_FL, XZQCode);
}
}
}
else//新增/BSM唯一
{
if (string.IsNullOrWhiteSpace(GX_BSM))//BSM为空，默认为新增图斑
{ //新增图斑重新编BSM
string bsmPrefix = MaxBSM.Substring(0, 10);
int MaxNum = Convert.ToInt32(MaxBSM.Substring(9));
MaxBSM = bsmPrefix + (MaxNum + 1).ToString().PadLeft(8, '0');
GX_f.Value[BSMGXIndex] = MaxBSM;
GX_f.Store();
}
ExeZLDataGeneration(GX_f, jcdltb_Layer, null, _curDLTBGX_FL, _curDLTBGXGC_FL, XZQCode);
}
}
refresh.OnClick();
this.CloseLoading();
MessageHelper.ShowTips("增量数据批量更新成功！");
}
catch (Exception ex)
{
LogAPI.Debug("增量数据批量更新失败！");
LogAPI.Debug(ex);
this.CloseLoading();
MessageHelper.ShowError("保存失败：" + ex.Message);
}
finally
{
this.CloseLoading();
}
}
/// <summary>
/// 增量数据变更前数据检查
/// </summary>
/// <param name="GX_f">修改过得更新图斑</param>
/// <returns></returns>
private bool DataSpecificationCheck(IFeature GX_f)
{
IFeature feature = GX_f;
string dbpath = System.IO.Path.GetDirectoryName((MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).GetProjFilePath()) + @"\BGTJ.sqlite";
if (rdbHelper == null)
rdbHelper = RDBFactory.CreateDbHelper("Data Source=" + dbpath, DatabaseType.SQLite);
if (rdbHelper == null)
{
throw new Exception("数据库连接打开失败：" + dbpath);
}
this.UpdateMsg("正在进行增量数据变更数据规范性检查.........");
if (dtDict == null)
dtDict = rdbHelper.ExecuteDatatable("Sys_DicType", $"SELECT CODE,NAME FROM Sys_DicDetail WHERE OWNERDIC='2' ", true);
List<DataDicTionary> DicsZZSX = Platform.Instance.DicHelper.GetDic(DicTypeEnum.ZZSX);
List<DataDicTionary> DicsXHLX = Platform.Instance.DicHelper.GetDic(DicTypeEnum.TBXHLX);
try
{
#region 属性
int iQSDWDM = _curDLTBGX_FL.FeatureClass.Fields.FindField("QSDWDM");//权属单位代码
int iQSDWMC = _curDLTBGX_FL.FeatureClass.Fields.FindField("QSDWMC");//权属单位名称
int iZLDWDM = _curDLTBGX_FL.FeatureClass.Fields.FindField("ZLDWDM");//坐落单位代码
int iZLDWMC = _curDLTBGX_FL.FeatureClass.Fields.FindField("ZLDWMC");//坐落单位名称
int iMSSM = _curDLTBGX_FL.FeatureClass.Fields.FindField("MSSM");//描述说明
int iDLBM = _curDLTBGX_FL.FeatureClass.Fields.FindField("DLBM");//地类编码
int iDLMC = _curDLTBGX_FL.FeatureClass.Fields.FindField("DLMC");//地类名称
int iQSXZ = _curDLTBGX_FL.FeatureClass.Fields.FindField("QSXZ");//权属性质
int iGDPDJB = _curDLTBGX_FL.FeatureClass.Fields.FindField("GDPDJB");//耕地坡度级别
int iKCDLXS = _curDLTBGX_FL.FeatureClass.Fields.FindField("KCXS");//扣除地类系数
int iKCDLBM = _curDLTBGX_FL.FeatureClass.Fields.FindField("KCDLBM");//扣除地类编码
int iGDLX = _curDLTBGX_FL.FeatureClass.Fields.FindField("GDLX");//耕地类型
int iGDDB = _curDLTBGX_FL.FeatureClass.Fields.FindField("GDDB");//耕地等别
int iTBXHDM = _curDLTBGX_FL.FeatureClass.Fields.FindField("TBXHDM");//图斑细化代码
int iTBXHMC = _curDLTBGX_FL.FeatureClass.Fields.FindField("TBXHMC");//图斑细化名称
int iZZSXDM = _curDLTBGX_FL.FeatureClass.Fields.FindField("ZZSXDM");//种植属性代码
int iZZSXMC = _curDLTBGX_FL.FeatureClass.Fields.FindField("ZZSXMC");//种植属性名称
int iCZCSXM = _curDLTBGX_FL.FeatureClass.Fields.FindField("CZCSXM");//城镇村属性码
int iXZDWKD = _curDLTBGX_FL.FeatureClass.Fields.FindField("XZDWKD");//线状地物宽度
int iBZ = _curDLTBGX_FL.FeatureClass.Fields.FindField("BZ");//备注
int iFRDBS = _curDLTBGX_FL.FeatureClass.Fields.FindField("FRDBS");//飞入地标识
int iBSM = _curDLTBGX_FL.FeatureClass.Fields.FindField("BSM");//标识码
#endregion
string strDLBM = feature.Value[iDLBM].ToTrim();
if (!string.IsNullOrEmpty(strDLBM) && strDLBM.Length > 2)
{
strDLBM = strDLBM.Substring(0, 2);
}
LogAPI.Debug("增量数据变更数据规范性检查开始.........OID:" + GX_f.OID);
string ErrLogs = string.Empty;
if (string.IsNullOrEmpty(feature.Value[iQSDWDM].ToTrim()) || string.IsNullOrEmpty(feature.Value[iQSDWMC].ToTrim()) || string.IsNullOrEmpty(feature.Value[iZLDWDM].ToTrim()) || string.IsNullOrEmpty(feature.Value[iZLDWMC].ToTrim()))
{
ErrLogs += "权属/坐落不可为空！\r\n";
LogAPI.Debug("权属/坐落不可为空！");
}
if (string.IsNullOrEmpty(feature.Value[iMSSM].ToTrim()))
{
ErrLogs += "描述说明不可为空！\r\n";
LogAPI.Debug("描述说明不可为空！");
}
//地类名称/代码
if (string.IsNullOrEmpty(feature.Value[iDLBM].ToTrim()) || string.IsNullOrEmpty(feature.Value[iDLMC].ToTrim()))
{
ErrLogs += "地类名称/代码不可为空！\r\n";
LogAPI.Debug("地类名称/代码不可为空！");
}
else
{
var dtrow = dtDict.Select($"CODE = '{feature.Value[iDLBM].ToString()}'");
if (dtrow.Length > 0 && feature.Value[iDLMC].ToTrim() != dtrow[0]["NAME"].ToTrim())
{
ErrLogs += "当前的地类名称填写错误！\r\n";
LogAPI.Debug("当前的地类名称填写错误！" + feature.Value[iDLMC].ToString());
}
else if (dtrow.Length <= 0)
{
ErrLogs += "当前的地类编码在字典中不存在！\r\n";
LogAPI.Debug("当前的地类编码在字典中不存在！" + feature.Value[iDLBM].ToString());
}
}
//权属性质
if ((feature.Value[iQSXZ].ToString() == "21" || feature.Value[iQSXZ].ToString() == "41") && feature.Value[iMSSM].ToTrim() != "01")
{
ErrLogs += "权属性质为21/41,描述说明应该为01！\r\n";
LogAPI.Debug("权属性质为21/41,描述说明应该为01！");
}
//耕地坡度级别/扣除地类系数/扣除地类编码
if (!string.IsNullOrEmpty(feature.Value[iDLBM].ToTrim()))
{
if (strDLBM != "01" && !(string.IsNullOrWhiteSpace(feature.Value[iKCDLXS].ToTrim()) || feature.Value[iKCDLXS].ToTrim() == "0"))
{
ErrLogs += "地类为非01类图斑，扣除地类系数应该为0！\r\n";
LogAPI.Debug("地类为非01类图斑，扣除地类系数应该为0！");
}
if (strDLBM != "01" && !string.IsNullOrWhiteSpace(feature.Value[iKCDLBM].ToTrim()))
{
ErrLogs += "地类为非01类图斑，扣除地类编码应该为空！\r\n";
LogAPI.Debug("地类为非01类图斑，扣除地类编码应该为空！");
}
if (strDLBM != "01" && !string.IsNullOrWhiteSpace(feature.Value[iGDPDJB].ToTrim()))
{
ErrLogs += "地类为非01类图斑，耕地坡度级别应该为空！\r\n";
LogAPI.Debug("地类为非01类图斑，耕地坡度级别应该为空！");
}
}
//耕地类型/耕地等别
if (!string.IsNullOrEmpty(feature.Value[iDLBM].ToTrim()))
{
if (strDLBM != "01" && !string.IsNullOrWhiteSpace(feature.Value[iGDLX].ToTrim()))
{
ErrLogs += "地类为非01类图斑，耕地类型应该为空！\r\n";
LogAPI.Debug("地类为非01类图斑，耕地类型应该为空！");
}
if (strDLBM != "01" && !(string.IsNullOrWhiteSpace(feature.Value[iGDDB].ToTrim()) || feature.Value[iGDDB].ToTrim() == "0"))
{
ErrLogs += "地类为非01类图斑，耕地等别应该为空！\r\n";
LogAPI.Debug("地类为非01类图斑，耕地等别应该为空！");
}
}
List<string> liststr = new List<string>() { "HDGD", "HQGD", "LQGD", "MQGD", "SHGD", "SMGD", "YJGD" };
//图斑细化代码/图斑细化名称
if (!string.IsNullOrEmpty(feature.Value[iDLBM].ToTrim()))
{
//非01类图斑，图斑细化代码标注HDGD、HQGD、LQGD、MQGD、SHGD、SMGD、YJGD的需清空。
if (strDLBM != "01" && liststr.Contains(feature.Value[iTBXHDM].ToString()))
{
if (feature.Value[iTBXHDM].ToTrim() == "" || feature.Value[iTBXHMC].ToTrim() == "")
{
ErrLogs += "地类为非01类图斑，图斑细化代码不应该为HDGD,HQGD,LQGD,MQGD,SHGD,SMGD,YJGD中的其一，应清空图斑细化代码、名称！\r\n";
LogAPI.Debug("地类为非01类图斑，图斑细化代码不应该为HDGD,HQGD,LQGD,MQGD,SHGD,SMGD,YJGD中的其一，应清空图斑细化代码、名称！");
}
}
//非06类用地，TBXHDM字段为HDGY、GTGY、MTGY、SNGY、BLGY、DLGY的需清空。
liststr = new List<string>() { "HDGY", "GTGY", "MTGY", "SNGY", "BLGY", "DLGY" };
if (strDLBM != "06" && liststr.Contains(feature.Value[iTBXHDM].ToString()))
{
if (feature.Value[iTBXHDM].ToTrim() == "" || feature.Value[iTBXHMC].ToTrim() == "")
{
ErrLogs += "地类为非06类图斑，图斑细化代码不应该为HDGY,GTGY,MTGY,SNGY,BLGY,DLGY中的其一，应清空图斑细化代码、名称！\r\n";
LogAPI.Debug("地类为非06类图斑，图斑细化代码不应该为HDGY,GTGY,MTGY,SNGY,BLGY,DLGY中的其一，应清空图斑细化代码、名称！");
}
}
//非04类图斑，标注GCCD的需清除。
if (strDLBM != "04" && feature.Value[iTBXHDM].ToString() == "GCCD")
{
if (feature.Value[iTBXHDM].ToTrim() == "" || feature.Value[iTBXHMC].ToTrim() == "")
{
ErrLogs += "地类为非04类，图斑细化代码不应该为GCCD，应清空图斑细化代码、名称！\r\n";
LogAPI.Debug("地类为非04类，图斑细化代码不应该为GCCD，应清空图斑细化代码、名称！");
}
}
//非03类，0404的图斑，标注LJTM的需要清除。
if ((strDLBM != "03" || feature.Value[iDLBM].ToString() == "0404") && feature.Value[iTBXHDM].ToString() == "LJTM")
{
if (feature.Value[iTBXHDM].ToTrim() == "" || feature.Value[iTBXHMC].ToTrim() == "")
{
ErrLogs += "地类为非03类或非0404，图斑细化代码不应该为LJTM，应清空图斑细化代码、名称！\r\n";
LogAPI.Debug("地类为非03类或非0404，图斑细化代码不应该为LJTM，应清空图斑细化代码、名称！");
}
}
//地类编码字段前2位非01、02、03、04，且不等于0601、0602、1001、1003，或属于湿地的，不能进行图斑细化标注
liststr = new List<string>() { "01", "02", "03", "04", "0601", "0602", "1001", "1003", "0303", "0304", "0306", "0402", "0603", "1105", "1106", "1108" };
if (!liststr.Contains(strDLBM) && !liststr.Contains(feature.Value[iDLBM].ToString()))
{
if (feature.Value[iTBXHDM].ToTrim() != "" || feature.Value[iTBXHMC].ToTrim() != "")
{
ErrLogs += "地类编码字段为非‘01类,02类,03类,04类,0601,0602,1001,1003,0303,0304,0306,0402,0603,1105,1106,1108’,不能进行图斑细化标注，应清空图斑细化代码、名称！\r\n";
LogAPI.Debug("地类编码字段为非‘01类,02类,03类,04类,0601,0602,1001,1003,0303,0304,0306,0402,0603,1105,1106,1108’,不能进行图斑细化标注，应清空图斑细化代码、名称！");
}
}
}
//种植属性代码/种植属性名称
if (!string.IsNullOrEmpty(feature.Value[iDLBM].ToTrim()))
{
//非01类图斑，种植属性代码标注LS、FLS、LYFL、XG、LLJZ、WG的需要清空；
liststr = new List<string>() { "LS", "FLS", "LYFL", "XG", "LLJZ", "WG" };
if (strDLBM != "01" && !strDLBM.StartsWith("01") && liststr.Contains(feature.Value[iZZSXDM].ToTrim()))
{
if (feature.Value[iZZSXDM].ToTrim() == "" || feature.Value[iZZSXMC].ToTrim() == "")
{
ErrLogs += "地类为非01类图斑，种植属性代码标注LS、FLS、LYFL、XG、LLJZ、WG，应清空种植属性代码、名称！\r\n";
LogAPI.Debug("地类为非01类图斑，种植属性代码标注LS、FLS、LYFL、XG、LLJZ、WG，应清空种植属性代码、名称！");
}
}
//非0301、0302、0305、0307、0404、1104、1104A，0201、0202、0203、0204、0201K、0202K、0203K、0204K、0301K、0302K、0307K、0403K、1104K的种植属性代码填写JKHF、GCHF的需清空。
liststr = new List<string>() { "0301", "0302", "0305", "0307", "0404", "1104", "1104A", "0201", "0202", "0203", "0204", "0201K", "0202K", "0203K", "0204K", "0301K", "0302K", "0307K", "0403K", "1104K" };
if (!liststr.Contains(feature.Value[iDLBM].ToTrim()) && (feature.Value[iZZSXDM].ToTrim() == "JKHF" || feature.Value[iZZSXDM].ToTrim() == "GCHF"))
{
if (feature.Value[iZZSXDM].ToTrim() == "" || feature.Value[iZZSXMC].ToTrim() == "")
{
ErrLogs += "地类为非0301、0302、0305、0307、0404、1104、1104A，0201、0202、0203、0204、0201K、0202K、0203K、0204K、0301K、0302K、0307K、0403K、1104K的图斑，种植属性代码标注JKHF、GCHF，应清空种植属性代码、名称！\r\n";
LogAPI.Debug("地类为非0301、0302、0305、0307、0404、1104、1104A，0201、0202、0203、0204、0201K、0202K、0203K、0204K、0301K、0302K、0307K、0403K、1104K的图斑，种植属性代码标注JKHF、GCHF，应清空种植属性代码、名称！");
}
}
//地类编码字段前2位为04（不包括0404、0403K)、05、06、07、08、09、10、11（不包括1104、1104A、1104K）、12，或属于湿地的，不能进行种植属性标注或恢复属性标注;
liststr = new List<string>() { "04", "05", "06", "07", "08", "09", "10", "11", "12", "0303", "0304", "0306", "0402", "0603", "1105", "1106", "1108" };
var liststr1 = new List<string>() { "0404", "0403K", "1104", "1104A", "1104K" };
if ((liststr.Contains(strDLBM) || liststr.Contains(feature.Value[iDLBM].ToTrim())) && !liststr1.Contains(feature.Value[iDLBM].ToTrim()))
{
if (feature.Value[iZZSXDM].ToTrim() != "" || feature.Value[iZZSXMC].ToTrim() != "")
{
ErrLogs += "地类编码字段前2位为04（不包括0404、0403K)、05、06、07、08、09、10、11（不包括1104、1104A、1104K）、12，或属于湿地的图斑，应清空种植属性代码、名称！\r\n";
LogAPI.Debug("地类编码字段前2位为04（不包括0404、0403K)、05、06、07、08、09、10、11（不包括1104、1104A、1104K）、12，或属于湿地的图斑，应清空种植属性代码、名称！");
}
}
}
//城镇村属性码
if (!string.IsNullOrEmpty(feature.Value[iDLBM].ToTrim()))
{
//1001、1002、1003、1007、1008、1009、1109的图斑，城镇村属性码应为空
liststr = new List<string>() { "1001", "1002", "1003", "1007", "1008", "1009", "1109" };
if (liststr.Contains(feature.Value[iDLBM].ToString()))
{
if (feature.Value[iCZCSXM].ToTrim() != "")
{
ErrLogs += "地类为1001、1002、1003、1007、1008、1009、1109的图斑，城镇村属性码应为空！\r\n";
LogAPI.Debug("地类为1001、1002、1003、1007、1008、1009、1109的图斑，城镇村属性码应为空！");
}
}
}
//线状地物宽度
if (!string.IsNullOrEmpty(feature.Value[iDLBM].ToTrim()))
{
//非线性图斑要清除线状地物宽度
liststr = new List<string>() { "1001", "1002", "1003", "1004", "1006", "1009", "1101", "1107", "1107A", "1203" };
if (!liststr.Contains(feature.Value[iDLBM].ToString()) && feature.Value[iXZDWKD].ToString() != "0")
{
if (feature.Value[iXZDWKD].ToTrim() != "0")
{
ErrLogs += "地类为1001、1002、1003、1007、1008、1009、1109、1101、1107、1107A、1203的图斑，线状地物宽度应为0！\r\n";
LogAPI.Debug("地类为1001、1002、1003、1007、1008、1009、1109、1101、1107、1107A、1203的图斑，线状地物宽度应为0！");
}
}
}
//飞入地标识
if (string.IsNullOrEmpty(feature.Value[iFRDBS].ToTrim()))
{
ErrLogs += "飞入地标识不能为空！";
LogAPI.Debug("飞入地标识不能为空！");
}
LogAPI.Debug("增量数据变更数据规范性检查结束.........");
if (!string.IsNullOrEmpty(ErrLogs))
{
MessageHelper.ShowTips(string.Format("数据检查过程中出现填写不规范！\r\n{0}", ErrLogs));
return false;
}
else
{
return true;
}
}
catch (Exception ex)
{
LogAPI.Debug("增量变更数据规范性检查报错，详情如下:");
LogAPI.Debug(ex);
MessageHelper.ShowError("增量变更数据规范性检查报错,请查看日志！");
return false;
}
}
/// <summary>
/// 删除增量数据
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BtnDele_Click(object sender, RoutedEventArgs e)
{
try
{
if (pEditor.EditState != esriEngineEditState.esriEngineStateEditing)
{
MessageHelper.ShowTips("请先开启图层编辑！");
return;
}
if (_curDLTBGX_FL == null)
_curDLTBGX_FL = MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBGX");
IFeature DeleGX_f = null;
if (SaveFeatureOID != -1)
{
try
{
DeleGX_f = _curDLTBGX_FL.FeatureClass.GetFeature(SaveFeatureOID);
}
catch (Exception)
{
MessageHelper.ShowError("获取当前图斑失败，请刷新后再尝试！");
return;
}
}
else return;
#region 图层字段
int BGQBSMGXGCIndex = _curDLTBGXGC_FL.FeatureClass.FindField("BGQTBBSM");
int BGHBSMGXGCIndex = _curDLTBGXGC_FL.FeatureClass.FindField("BGHTBBSM");
int BSMGXIndex = _curDLTBGX_FL.FeatureClass.FindField("BSM");
int BGMJIndex = _curDLTBGX_FL.FeatureClass.FindField("TBMJ");
int JCBSMGXIndex = jcdltb_Layer.FeatureClass.FindField("BSM");
ITable tableGC = _curDLTBGXGC_FL.FeatureClass as ITable;
ITable tableGX = _curDLTBGX_FL.FeatureClass as ITable;
if (jc_FieldsIndex == null || jc_FieldsIndex.Count == 0)
jc_FieldsIndex = GetFieldsIndex(jcdltb_Layer.FeatureClass.Fields);
if (gx_FieldsIndex == null || gx_FieldsIndex.Count == 0)
gx_FieldsIndex = GetFieldsIndex(_curDLTBGX_FL.FeatureClass.Fields);
if (gxgc_FieldsIndex == null || gxgc_FieldsIndex.Count == 0)
gxgc_FieldsIndex = GetFieldsIndex(_curDLTBGXGC_FL.FeatureClass.Fields);
#endregion
string GXBSM = DeleGX_f.Value[BSMGXIndex].ToString().Trim();
if (string.IsNullOrWhiteSpace(GXBSM))
MessageHelper.ShowTips("当前数据标识码为空！");
else
{
this.ShowLoading("正在进行变更数据还原操作........", 0, 0);
IQueryFilter queryFilter = new QueryFilterClass
{
WhereClause = string.Format("BGHTBBSM='{0}'", GXBSM)
};
DLTBGXAttribute temp_De = new DLTBGXAttribute(gx_FieldsIndex);
temp_De.OID = DeleGX_f.OID;
temp_De.Shape2 = DeleGX_f.ShapeCopy;//删除增量数据，属性还原成基础图斑属性
temp_De.GCDataList.AddRange(GetDLTBGXGCs(temp_De, DeleGX_f));
if (temp_De.GCDataList.Count == 1)
{
List<IFeature> JC_Fs = FeatureAPI.Identify2(temp_De.GCDataList[0].Shape, jcdltb_Layer);
int length = JC_Fs.Count;
if (JC_Fs.Count == 1 && FeatureAPI.IsContains(JC_Fs[0].ShapeCopy, temp_De.Shape2))
{
DLTBGXAttribute dLTBGXAttribute = new DLTBGXAttribute(gx_FieldsIndex);
dLTBGXAttribute.SetAttribure(JC_Fs[0], jc_FieldsIndex);
temp_De.SetAttribure(DeleGX_f);//被动变更图斑不需要还原
if (dLTBGXAttribute.IsEqual(temp_De)) return;
}
else
{
for (int i = 0; i < length; i++)
{
if (!FeatureAPI.IsContains(JC_Fs[i].ShapeCopy, temp_De.GCDataList[0].Shape))
{ JC_Fs.Remove(JC_Fs[i]); i--; length--; }//剔除边界压盖基础图斑
}
}
temp_De.SetAttribure(JC_Fs[0], jc_FieldsIndex);//还原更新数据为基础数据属性
temp_De.GCDataList[0].SetBGHAttribure(temp_De);//对应过程数据还原为基础图斑
temp_De.GCDataList[0].SetBGQAttribure(JC_Fs[0], gxgc_FieldsIndex);//对应过程数据还原为基础图斑
//当前更新图斑与基础图斑边界保持一致，直接删除
if (FeatureAPI.IsContains(DeleGX_f.ShapeCopy, JC_Fs[0].ShapeCopy) || FeatureAPI.GetEqual(DeleGX_f.ShapeCopy, JC_Fs[0].ShapeCopy))
{
Platform.Instance.SendMsg(new NotifyMsgPackage() { Content = DeleGX_f.OID, MsgType = "RefreshViewAttrTable", Extend = "DelDataByOID" });
DeleGX_f.Delete();
tableGC.DeleteSearchedRows(queryFilter);
return;
}
else if (FeatureAPI.IsContains(JC_Fs[0].ShapeCopy, DeleGX_f.ShapeCopy) && !FeatureAPI.GetEqual(DeleGX_f.ShapeCopy, JC_Fs[0].ShapeCopy))
{
List<IFeature> GX_Fs = FeatureAPI.Identify(DeleGX_f.ShapeCopy, _curDLTBGX_FL);
foreach (IFeature ZBGX_Fitem in GX_Fs)
{
if (ZBGX_Fitem.OID == DeleGX_f.OID) continue;
if (!FeatureAPI.IsContains(JC_Fs[0].ShapeCopy, ZBGX_Fitem.ShapeCopy)) continue;
DLTBGXAttribute tempgx = new DLTBGXAttribute(gx_FieldsIndex);
tempgx.SetAttribure(ZBGX_Fitem, gx_FieldsIndex);//周边更新数据属性
tempgx.Shape2 = ZBGX_Fitem.ShapeCopy;
if (temp_De.IsEqual(tempgx))//存在周边更新图斑与基础图斑一致时，才删除当前更新数据
{
tempgx.GCDataList.AddRange(GetDLTBGXGCs(tempgx, ZBGX_Fitem));
foreach (DLTBGXGCAttribute GC_item in temp_De.GCDataList)
{
//验证数据的准确性
DLTBGXGCAttribute dLTBGXGC = tempgx.GCDataList.FirstOrDefault(x => x.FieldsValue["BGQTBBSM"].ToString() == JC_Fs[0].Value[JCBSMGXIndex].ToString());
if (dLTBGXGC != null)
{
temp_De.IsUpdate = true;
temp_De.BSM = "";
GC_item.BGMJ += dLTBGXGC.BGMJ;
GC_item.Shape = FeatureAPI.Union(GC_item.Shape, dLTBGXGC.Shape);
queryFilter.WhereClause = string.Format("BGHTBBSM='{0}'", ZBGX_Fitem.Value[BSMGXIndex].ToTrim());
tableGC.DeleteSearchedRows(queryFilter);
Platform.Instance.SendMsg(new NotifyMsgPackage() { Content = ZBGX_Fitem.OID, MsgType = "RefreshViewAttrTable", Extend = "DelDataByOID" });
ZBGX_Fitem.Delete();
}
}
}
}
if (temp_De.IsUpdate == true)//存在合并状况
{
queryFilter.WhereClause = string.Format("BGHTBBSM='{0}'", DeleGX_f.Value[BSMGXIndex].ToTrim());
tableGC.DeleteSearchedRows(queryFilter);
Platform.Instance.SendMsg(new NotifyMsgPackage() { Content = DeleGX_f.OID, MsgType = "RefreshViewAttrTable", Extend = "DelDataByOID" });
DeleGX_f.Delete();
if (string.IsNullOrWhiteSpace(MaxBSM))
MaxBSM = GetMaxBSM(new List<IFeatureClass>() { _curDLTBGX_FL.FeatureClass, _curDLTBGXGC_FL.FeatureClass });
//与基础图斑边界一致，默认还原变更
if (!FeatureAPI.GetEqual(temp_De.Shape, JC_Fs[0].ShapeCopy))
{
InsertGXFeature(temp_De, _curDLTBGX_FL);
foreach (DLTBGXGCAttribute GCItem in temp_De.GCDataList)
{
InsertGXGCFeature(GCItem, temp_De, _curDLTBGXGC_FL);
}
}
}
else//仅当前更新数据及变更层作修改
{
UpdateGXFeature(DeleGX_f, temp_De, false);
foreach (DLTBGXGCAttribute GCItem in temp_De.GCDataList)
{
IFeature feature = _curDLTBGXGC_FL.FeatureClass.GetFeature(GCItem.UpdateOID);
UpdateGCFeature(feature, GCItem);
}
}
}
}
else
{
//存储周边更新数据改的
List<DLTBGXAttribute> NewGXAtts = new List<DLTBGXAttribute>();//被修改的图斑
List<DLTBGXGCAttribute> OldZBGXGCAtts = new List<DLTBGXGCAttribute>();//被合并的图斑
DLTBGXAttribute temp_DelPart = new DLTBGXAttribute(gx_FieldsIndex);
temp_DelPart.Shape2 = DeleGX_f.ShapeCopy;//增量数据
temp_DelPart.GCDataList.AddRange(GetDLTBGXGCs(temp_DelPart, DeleGX_f));
foreach (DLTBGXGCAttribute DelGCAttriitem in temp_DelPart.GCDataList)
{
List<IFeature> JCFsByGC = FeatureAPI.Identify(DelGCAttriitem.Shape, jcdltb_Layer);
if (JCFsByGC != null && JCFsByGC.Count != 0)//过程层只能压盖到对应的基础图斑
{
int length = JCFsByGC.Count;
for (int i = 0; i < length; i++)
{
if (JCFsByGC[i].Value[JCBSMGXIndex].ToString().Trim() != DelGCAttriitem.FieldsValue["BGQTBBSM"].ToString())
{ JCFsByGC.Remove(JCFsByGC[i]); i--; length--; }//剔除边界压盖基础图斑
}
DLTBGXAttribute NewGXAttribute = new DLTBGXAttribute(gx_FieldsIndex);
NewGXAttribute.SetAttribure(JCFsByGC[0], jc_FieldsIndex);
List<IFeature> ZBGCs = FeatureAPI.Identify(DelGCAttriitem.Shape, _curDLTBGXGC_FL);
foreach (IFeature ZBGC_Fitem in ZBGCs)
{
if (DelGCAttriitem.UpdateOID == ZBGC_Fitem.OID)
{
Platform.Instance.SendMsg(new NotifyMsgPackage() { Content = ZBGC_Fitem.OID, MsgType = "RefreshViewAttrTable", Extend = "DelDataByOID" });
ZBGC_Fitem.Delete();
continue;
}
DLTBGXGCAttribute dLTBGXGC = new DLTBGXGCAttribute(gxgc_FieldsIndex);//ZB
dLTBGXGC.SetAttribure(ZBGC_Fitem, gxgc_FieldsIndex);
dLTBGXGC.Shape = ZBGC_Fitem.ShapeCopy;
if (JCFsByGC[0].Value[JCBSMGXIndex].ToString().Trim() != dLTBGXGC.FieldsValue["BGQTBBSM"].ToString()) continue;
//if (!FeatureAPI.IsContains(JCFsByGC[0].ShapeCopy, ZBGC_Fitem.ShapeCopy)) continue;
//temp_DelPart.SetAttribure(JCFsByGC[0], jc_FieldsIndex);
double GCBGMJ = DelGCAttriitem.BGMJ;//还原之前的过程图斑面积
DelGCAttriitem.SetBGHAttribure(JCFsByGC[0], jc_FieldsIndex);
if (dLTBGXGC.BGHAttribureIsEqual(DelGCAttriitem))//相邻的过程层属性一致
{
DelGCAttriitem.Shape = FeatureAPI.Union(dLTBGXGC.Shape, DelGCAttriitem.Shape);
DelGCAttriitem.BGMJ += dLTBGXGC.BGMJ;
DelGCAttriitem.IsUpdate = true;
NewGXAttribute.Shape2 = DelGCAttriitem.Shape;
NewGXAttribute.TBMJ += DelGCAttriitem.BGMJ;
NewGXAttribute.BSM = "";
NewGXAttribute.GCDataList.Add(DelGCAttriitem);
Platform.Instance.SendMsg(new NotifyMsgPackage() { Content = ZBGC_Fitem.OID, MsgType = "RefreshViewAttrTable", Extend = "DelDataByOID" });
ZBGC_Fitem.Delete();
OldZBGXGCAtts.Add(dLTBGXGC);//参与合并，
}
else
{
NewGXAttribute.Shape2 = DelGCAttriitem.Shape;//最开始的图形赋值
NewGXAttribute.GCDataList.Add(DelGCAttriitem);//本身作为被动变更
}
}
if (NewGXAttribute.GCDataList.Count != 0)
{
if (!FeatureAPI.GetEqual(NewGXAttribute.Shape, JCFsByGC[0].ShapeCopy))
{
NewGXAtts.Add(NewGXAttribute);//还原为基础图斑属性(无论修改，覆盖/未改变)
}
}
}
}
if (string.IsNullOrWhiteSpace(MaxBSM) && NewGXAtts.Count != 0)
MaxBSM = GetMaxBSM(new List<IFeatureClass>() { _curDLTBGX_FL.FeatureClass, _curDLTBGXGC_FL.FeatureClass });
foreach (DLTBGXAttribute GXItem in NewGXAtts)
{
InsertGXFeature(GXItem, _curDLTBGX_FL);
foreach (DLTBGXGCAttribute GCItem in GXItem.GCDataList)
{
InsertGXGCFeature(GCItem, GXItem, _curDLTBGXGC_FL);
}
}
foreach (DLTBGXGCAttribute item in OldZBGXGCAtts)
{
queryFilter.WhereClause = string.Format("BSM='{0}'", item.BGHTBBSM);
IFeatureCursor featureCursor = _curDLTBGX_FL.FeatureClass.Update(queryFilter, false);
IFeature feature = null;
if ((feature = featureCursor.NextFeature()) != null)
{
Platform.Instance.SendMsg(new NotifyMsgPackage() { Content = feature.OID, MsgType = "RefreshViewAttrTable", Extend = "DelDataByOID" });
feature.Delete();
}
}
Platform.Instance.SendMsg(new NotifyMsgPackage() { Content = DeleGX_f.OID, MsgType = "RefreshViewAttrTable", Extend = "DelDataByOID" });
DeleGX_f.Delete();
}//默认不存在压盖不到基础图斑
this.CloseLoading();
refresh.OnClick();
MessageHelper.ShowTips("增量数据还原成功！");
}
}
catch (Exception ex)
{
LogAPI.Debug("增量数据更新还原失败,原因如下：");
LogAPI.Debug(ex);
this.CloseLoading();
MessageHelper.ShowTips("增量数据更新还原失败，请重新选择！");
}
finally
{
this.CloseLoading();
SaveFeatureOID = -1;
_FeatureInfo.BindData(_curDLTBGX_FL.FeatureClass.CreateFeatureBuffer() as IFeature);
}
}
private List<DLTBGXGCAttribute> GetDLTBGXGCs(DLTBGXAttribute DLTBGXAttribute, IFeature Temp_F)
{
List<DLTBGXGCAttribute> TempGCs = new List<DLTBGXGCAttribute>();
int indexGX = _curDLTBGX_FL.FeatureClass.FindField("BSM");
IQueryFilter queryFilter = new QueryFilterClass
{
WhereClause = string.Format("BGHTBBSM='{0}'", Temp_F.Value[indexGX].ToTrim())
};
IFeatureCursor featureCursor_GC = _curDLTBGXGC_FL.FeatureClass.Update(queryFilter, false);
IFeature featureGC = null;//当前更新图斑对应过程层数据
while ((featureGC = featureCursor_GC.NextFeature()) != null)
{
DLTBGXGCAttribute TempGC = new DLTBGXGCAttribute(gxgc_FieldsIndex);
TempGC.SetAttribure(featureGC, gxgc_FieldsIndex);
TempGC.Shape = featureGC.ShapeCopy;
TempGC.UpdateOID = featureGC.OID;
TempGCs.Add(TempGC);
}
return TempGCs;
}
List<DLTBGXAttribute> gxDataList = null;
/// <summary>
/// 过程层数据生成
/// </summary>
/// <param name="pBGFeature"></param>
/// <param name="pJC_Layer"></param>
/// <param name="pJC_Layer2"></param>
/// <param name="pGX_Layer"></param>
/// <param name="pGXGC_Layer"></param>
/// <param name="pTempBSMPrefix"></param>
/// <returns></returns>
private bool ExeZLDataGeneration(IFeature pGXFeature, IFeatureLayer pJC_Layer, IFeatureLayer pJC_Layer2, IFeatureLayer pGX_Layer, IFeatureLayer pGXGC_Layer, string pTempBSMPrefix)
{
bool result = false;
try
{
this.UpdateMsg("正在进行更新过程数据.......");
gxDataList = new List<DLTBGXAttribute>();
//获取更新数据过程数据
gxDataList = GetGXGCData2(pGXFeature, pJC_Layer, pGXGC_Layer, pGX_Layer);
gxDataList.ForEach(x => x.TBMJ = x.GCDataList.Sum(k => k.BGMJ));//平差后的过程面积求和
try
{
//修改更新数据
foreach (DLTBGXAttribute pGXData in gxDataList)
{
if (pGXData.IsAdd == true)//产生多环图形，全部按照新增操作
{
InsertGXFeature(pGXData, pGX_Layer, false);
continue;
}
IFeature featureGX = null;
try
{
featureGX = pGX_Layer.FeatureClass.GetFeature(pGXData.InheritOID);
}
catch (Exception)
{
InsertGXFeature(pGXData, pGX_Layer, false);
continue;
}
if (featureGX != null)
{
featureGX.Shape = pGXData.Shape;
foreach (var fieldName in gx_FieldsIndex.Keys)
{
if (fieldName == "TBMJ")
{
featureGX.Value[gx_FieldsIndex[fieldName]] = pGXData.TBMJ;
continue;
}
if (fieldName == "YSDM")
{
featureGX.Value[gx_FieldsIndex[fieldName]] = "2001010100";
continue;
}
if (fieldName == "TBBH")
{
featureGX.Value[gx_FieldsIndex[fieldName]] = pGXData.FieldsValue[fieldName];
continue;
}
if (fieldName == "TBDLMJ")
{
double dKCMJ_Temp = Math.Round(pGXData.TBMJ * pGXData.KCXS, 2);
featureGX.Value[gx_FieldsIndex[fieldName]] = Math.Round(pGXData.TBMJ - dKCMJ_Temp, 2);
continue;
}
featureGX.Value[gx_FieldsIndex[fieldName]] = pGXData.FieldsValue[fieldName];
}
featureGX.Store();
}
}
//最终数据和基础图标一致，则做清除,反之插入数据；(不放在添加前判断，是先获取逻辑过程数据，作为数据验证)
foreach (DLTBGXAttribute gx in gxDataList)
{
foreach (var gxgc in gx.GCDataList)
{
if (gxgc.BGXW == "1")
{
IQueryFilter queryFilter = new QueryFilterClass
{
WhereClause = string.Format("BSM='{0}'", gxgc.BGHTBBSM)
};
IFeatureCursor featureCursor = jcdltb_Layer.FeatureClass.Search(queryFilter, true);
IFeature jc = featureCursor.NextFeature();
DLTBGXAttribute jcData = new DLTBGXAttribute(gx_FieldsIndex);
jcData.SetAttribure(jc, jc_FieldsIndex);
if (gx.IsEqual(jcData))
{
queryFilter.WhereClause = string.Format("BSM='{0}'", gxgc.BGHTBBSM);
featureCursor = pGX_Layer.FeatureClass.Update(queryFilter, true);
IFeature featureGX = featureCursor.NextFeature();
Platform.Instance.SendMsg(new NotifyMsgPackage() { Content = featureGX.OID, MsgType = "RefreshViewAttrTable", Extend = "DelDataByOID" });
featureGX.Delete();
featureCursor.Flush();
continue;
}
}
int oid = InsertGXGCFeature(gxgc, gx, pGXGC_Layer);
LogAPI.Debug("增量数据变更-插入过程数据OID：" + oid);
}
}
}
catch (Exception ex)
{
LogAPI.Debug("增量数据变更-过程数据生成异常：" + ex.Message);
LogAPI.Debug(ex);
}
result = true;
}
catch (Exception ex)
{
LogAPI.Debug("图斑变更发生异常！异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("异常信息结束");
}
return result;
}
#region 获取最新标识码
private string GetMaxBSM(List<IFeatureClass> fcList)
{
//System.Windows.Forms.Application.DoEvents();
int xh = 0;
string MaxBSM = "";
string leftStr = string.Empty;
foreach (var fc in fcList)
{
string BSM = string.Empty;
int BSMIndex = fc.FindField("BSM");
if (BSMIndex == -1) return BSM;
ITable table = (ITable)fc;
// 创建一个ITableSort接口对象
ITableSort tableSort = new TableSortClass
{
Table = table,
Fields = "BSM"
};
tableSort.set_Ascending("BSM", false);
tableSort.Sort(null);
ICursor cursor = tableSort.Rows;
IRow row = cursor.NextRow();
if (row != null)
{
int maxBSM = 0;
int currBSM = 0;
string BSMStr = row.Value[BSMIndex].ToString();
if (BSMStr.Length != 18 && !string.IsNullOrWhiteSpace(BSMStr.Trim())) return BSM;
if (string.IsNullOrWhiteSpace(BSMStr)) continue;
string subBSMStr = BSMStr.Substring(9);
try
{
currBSM = Convert.ToInt32(subBSMStr);
}
catch (Exception)
{
return BSM;
}
if (currBSM > maxBSM) maxBSM = currBSM;
if (BSMStr.Length != 18) return BSM;
string maxStr = maxBSM.ToString();
int zeroNum = 9 - maxStr.Length;
for (int i = 0; i < zeroNum; i++)
{
maxStr = 0 + maxStr;
}
BSM = BSMStr.Substring(0, 9) + maxStr;
}
if (BSM.Length != 18)
continue;
int xh2 = Convert.ToInt32(BSM.Substring(10));
leftStr = BSM.Substring(0, 10);
if (xh < xh2)
{
xh = xh2;
MaxBSM = BSM;
}
}
return MaxBSM;
}
#endregion
public void UpdateGXFeature(IFeature pFeature, DLTBGXAttribute pData, bool IsUpdateBSM = false)
{
try
{
pFeature.Shape = pData.Shape;
foreach (var key in pData.FieldsIndex.Keys)
{
if (pData.FieldsValue == null)
{
break;
}
if (key == "JCTBBSM")
continue;
if (key == "BSM" && IsUpdateBSM == false)
continue;
if (key == "TBBH")
{
pFeature.Value[pData.FieldsIndex[key]] = pData.TBBH;
continue;
}
if (key == "SJNF")
{
pFeature.Value[pData.FieldsIndex[key]] = "2023";
continue;
}
if (key == "TBMJ")
{
pFeature.Value[pData.FieldsIndex[key]] = pData.TBMJ;
continue;
}
if (key == "BGTBOID")
{
pFeature.Value[pData.FieldsIndex[key]] = pData.BGTBOID;
continue;
}
if (key == "YSDM")
{
pFeature.Value[pData.FieldsIndex[key]] = "2001010100";
continue;
}
if (key == "GXSJ")
{
pFeature.Value[pData.FieldsIndex[key]] = DateTime.Now.Month >= 10 ? new DateTime(DateTime.Now.Year, 12, 31) : new DateTime(DateTime.Now.Year - 1, 12, 31);
continue;
}
if (pData.FieldsValue.Keys.Contains(key))
{
pFeature.Value[pData.FieldsIndex[key]] = pData.FieldsValue[key];
}
}
}
catch (Exception ex)
{
LogAPI.Debug("更新地类团更新数据异常：" + ex);
LogAPI.Debug("更新地类团更新数据异常：" + ex.Message);
LogAPI.Debug("更新地类团更新数据异常：" + ex.StackTrace);
throw ex;
}
}
public void UpdateGCFeature(IFeature pFeature, DLTBGXGCAttribute pData)
{
try
{
pFeature.Shape = pData.Shape;
foreach (var key in pData.FieldsIndex.Keys)
{
if (pData.FieldsValue == null)
{
break;
}
if (key == "JCTBBSM")
continue;
if (key == "SJNF")
{
pFeature.Value[pData.FieldsIndex[key]] = "2022";
continue;
}
if (key == "TBMJ")
{
pFeature.Value[pData.FieldsIndex[key]] = pData.BGMJ;
continue;
}
if (key == "BGTBOID")
{
pFeature.Value[pData.FieldsIndex[key]] = pData.BGTBOID;
continue;
}
if (key == "YSDM")
{
pFeature.Value[pData.FieldsIndex[key]] = "2001010100";
continue;
}
if (key == "GXSJ")
{
pFeature.Value[pData.FieldsIndex[key]] = DateTime.Now.Month >= 10 ? new DateTime(DateTime.Now.Year, 12, 31) : new DateTime(DateTime.Now.Year - 1, 12, 31);
continue;
}
if (pData.FieldsValue.Keys.Contains(key))
{
pFeature.Value[pData.FieldsIndex[key]] = pData.FieldsValue[key];
}
}
}
catch (Exception ex)
{
LogAPI.Debug("更新过程数据异常：" + ex);
LogAPI.Debug("更新过程数据异常：" + ex.Message);
LogAPI.Debug("更新过程数据异常：" + ex.StackTrace);
throw ex;
}
}
/// <summary>
/// 插入更新层数据
/// </summary>
/// <param name="pGXData"></param>
/// <param name="pGX_Layer"></param>
/// <param name="pGXGC_Layer"></param>
public void InsertGXFeature(DLTBGXAttribute pGXData, IFeatureLayer pGX_Layer, bool isUpdateTBBH = false)
{
IFeatureCursor updateCursor = null;
IFeatureCursor gx_cursor = null;
IFeatureBuffer gx_buffer = null;
try
{
if (pGXData.GCDataList.Count == 1)
{
//新增不需要合并的，判断BSM是否为空，为空认为是图形变更，需进行重新编号
if (string.IsNullOrWhiteSpace(pGXData.BSM))
{
string bsmPrefix = MaxBSM.Substring(0, 10);
int MaxNum = Convert.ToInt32(MaxBSM.Substring(9));
MaxBSM = bsmPrefix + (MaxNum + 1).ToString().PadLeft(8, '0');
pGXData.BSM = MaxBSM;
pGXData.GCDataList[0].BGHTBBSM = pGXData.BSM;
pGXData.GCDataList[0].BGHTBBH = pGXData.TBBH;
}
}
else if (pGXData.GCDataList.Count > 1)
{
//新增需要合并的，认为图形变更
if (string.IsNullOrWhiteSpace(pGXData.BSM))
{
string bsmPrefix = MaxBSM.Substring(0, 10);
int MaxNum = Convert.ToInt32(MaxBSM.Substring(9));
MaxBSM = bsmPrefix + (MaxNum + 1).ToString().PadLeft(8, '0');
pGXData.BSM = MaxBSM;
pGXData.GCDataList.ForEach(f => { f.BGXW = "2"; f.BGHTBBSM = pGXData.BSM; });
}
}
else
{
return;
}
gx_cursor = pGX_Layer.FeatureClass.Insert(true);
gx_buffer = pGX_Layer.FeatureClass.CreateFeatureBuffer();
gx_buffer.Shape = pGXData.Shape;
foreach (var fieldName in gx_FieldsIndex.Keys)
{
if (fieldName == "TBMJ")
{
gx_buffer.Value[gx_FieldsIndex[fieldName]] = pGXData.TBMJ;
continue;
}
if (fieldName == "GXSJ")
{
gx_buffer.Value[gx_FieldsIndex[fieldName]] = DateTime.Now.Month >= 10 ? new DateTime(DateTime.Now.Year, 12, 31) : new DateTime(DateTime.Now.Year - 1, 12, 31);
continue;
}
if (fieldName == "TBBH")
{
if (pGXData.GCDataList.Count == 1 && pGXData.GCDataList[0].BGXW == "1")
{
if (!isUpdateTBBH)
{
if (!string.IsNullOrWhiteSpace(pGXData.GCDataList[0].BGHTBBH))
gx_buffer.Value[gx_FieldsIndex[fieldName]] = pGXData.GCDataList[0].BGHTBBH;
else
gx_buffer.Value[gx_FieldsIndex[fieldName]] = pGXData.FieldsValue[fieldName];
}
else
{
gx_buffer.Value[gx_FieldsIndex[fieldName]] = pGXData.FieldsValue[fieldName];
}
}
else
{
gx_buffer.Value[gx_FieldsIndex[fieldName]] = pGXData.FieldsValue[fieldName];
}
continue;
}
if (fieldName == "YSDM")
{
gx_buffer.Value[gx_FieldsIndex[fieldName]] = "2001010100";
continue;
}
if (fieldName == "SJNF")
{
gx_buffer.Value[gx_FieldsIndex[fieldName]] = "2022";
continue;
}
if (fieldName == "KCMJ")
{
gx_buffer.Value[gx_FieldsIndex[fieldName]] = Math.Round(pGXData.TBMJ * pGXData.KCXS, 2);
continue;
}
if (fieldName == "TBDLMJ")
{
double dKCMJ_Temp = Math.Round(pGXData.TBMJ * pGXData.KCXS, 2);
gx_buffer.Value[gx_FieldsIndex[fieldName]] = Math.Round(pGXData.TBMJ - dKCMJ_Temp, 2);
continue;
}
if (fieldName == "BGTBOID")
{
gx_buffer.Value[gx_FieldsIndex[fieldName]] = pGXData.BGTBOID;
continue;
}
if (pGXData.FieldsValue.Keys.Contains(fieldName))
gx_buffer.Value[gx_FieldsIndex[fieldName]] = pGXData.FieldsValue[fieldName];
}
object oid = gx_cursor.InsertFeature(gx_buffer);
gx_cursor.Flush();
pGXData.OID = Convert.ToInt32(oid);
Marshal.ReleaseComObject(gx_buffer);
}
catch (Exception ex)
{
LogAPI.Debug("写入更新层数据时发生异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("异常信息结束");
}
finally
{
if (updateCursor != null)
Marshal.ReleaseComObject(updateCursor);
if (gx_cursor != null)
Marshal.ReleaseComObject(gx_cursor);
if (gx_buffer != null)
Marshal.ReleaseComObject(gx_buffer);
}
}
public int InsertGXGCFeature(DLTBGXGCAttribute pGxgc, DLTBGXAttribute pGx, IFeatureLayer pFC)
{
IFeatureCursor gxgc_cursor = null;
IFeatureBuffer gxgc_buffer = null;
try
{
gxgc_cursor = pFC.FeatureClass.Insert(true);
gxgc_buffer = pFC.FeatureClass.CreateFeatureBuffer();
gxgc_buffer.Shape = pGxgc.Shape;
foreach (var fieldName in gxgc_FieldsIndex.Keys)
{
if (fieldName == "BSM")
{
string bsmPrefix = MaxBSM.Substring(0, 10);
int MaxNum = Convert.ToInt32(MaxBSM.Substring(9));
MaxBSM = bsmPrefix + (MaxNum + 1).ToString().PadLeft(8, '0');
gxgc_buffer.Value[gxgc_FieldsIndex[fieldName]] = MaxBSM;
continue;
}
if (fieldName == "TBBGMJ")
{
gxgc_buffer.Value[gxgc_FieldsIndex[fieldName]] = pGxgc.BGMJ;
continue;
}
if (fieldName == "BGXW")
{
gxgc_buffer.Value[gxgc_FieldsIndex[fieldName]] = pGxgc.BGXW;
continue;
}
if (fieldName == "GXSJ")
{
gxgc_buffer.Value[gxgc_FieldsIndex[fieldName]] = DateTime.Now.Month >= 10 ? new DateTime(DateTime.Now.Year, 12, 31) : new DateTime(DateTime.Now.Year - 1, 12, 31);
continue;
}
if (fieldName == "BGTBOID")
{
gxgc_buffer.Value[gxgc_FieldsIndex[fieldName]] = pGxgc.BGTBOID;
continue;
}
if (fieldName == "BGHTBBSM")
{
gxgc_buffer.Value[gxgc_FieldsIndex[fieldName]] = pGx.BSM;
continue;
}
if (pGxgc.FieldsValue.Keys.Contains(fieldName) && fieldName.Contains("BGH") && pGx.FieldsValue.ContainsKey(GetRemovePrefixString(fieldName, "BGH")))
{
gxgc_buffer.Value[gxgc_FieldsIndex[fieldName]] = pGx.FieldsValue[GetRemovePrefixString(fieldName, "BGH")];
}
if (pGxgc.FieldsValue.Keys.Contains(fieldName) && !fieldName.Contains("BGH"))
gxgc_buffer.Value[gxgc_FieldsIndex[fieldName]] = pGxgc.FieldsValue[fieldName];
}
#region 变更前_面积维护
double kcxs = 0;
//获取变更前扣除系数
int buffer_F_Index = gxgc_buffer.Fields.FindField("BGQKCXS");
if (buffer_F_Index != -1)
{
if (!(gxgc_buffer.Value[buffer_F_Index] is DBNull))
kcxs = (double)gxgc_buffer.Value[buffer_F_Index];
}
//变更前扣除面积
double kcmj = 0;
buffer_F_Index = gxgc_buffer.Fields.FindField("BGQKCMJ");
if (buffer_F_Index != -1)
{
kcmj = Math.Round(pGxgc.BGMJ * kcxs, 2);
gxgc_buffer.Value[buffer_F_Index] = kcmj;
}
//变更前图斑地类面积
buffer_F_Index = gxgc_buffer.Fields.FindField("BGQTBDLMJ");
if (buffer_F_Index != -1)
{
gxgc_buffer.Value[buffer_F_Index] = pGxgc.BGMJ - kcmj;
}
#endregion
#region 变更后_面积维护
kcxs = 0;
//获取变更后扣除系数
buffer_F_Index = gxgc_buffer.Fields.FindField("BGHKCXS");
if (buffer_F_Index != -1)
{
if (!(gxgc_buffer.Value[buffer_F_Index] is DBNull))
kcxs = (double)gxgc_buffer.Value[buffer_F_Index];
}
//变更后扣除面积
kcmj = 0;
buffer_F_Index = gxgc_buffer.Fields.FindField("BGHKCMJ");
if (buffer_F_Index != -1)
{
kcmj = Math.Round(pGxgc.BGMJ * kcxs, 2);
gxgc_buffer.Value[buffer_F_Index] = kcmj;
}
//变更后图斑地类面积
buffer_F_Index = gxgc_buffer.Fields.FindField("BGHTBDLMJ");
if (buffer_F_Index != -1)
{
gxgc_buffer.Value[buffer_F_Index] = pGxgc.BGMJ - kcmj;
}
#endregion
object oid = gxgc_cursor.InsertFeature(gxgc_buffer);
gxgc_cursor.Flush();
Marshal.ReleaseComObject(gxgc_buffer);
return (int)oid;
}
catch (Exception ex)
{
LogAPI.Debug(ex.Message);
throw;
}
finally
{
if (gxgc_cursor != null)
Marshal.ReleaseComObject(gxgc_cursor);
}
}
private bool BGQ_BGH_AttrEqual(IFeature pf, ref string UnEqualAttr)
{
bool result = true;
for (int i = 0; i < pf.Fields.FieldCount; i++)
{
IField field = pf.Fields.Field[i];
if ("BSM".Contains(field.Name.ToUpper()) || field.Name.ToUpper().Contains("MJ")) continue;
int bghIdx = pf.Fields.FindField(field.Name.Replace("BGQ", "BGH"));
if (bghIdx == -1) continue;
if ("BGQTBBSM,BGQTBBH,BGQZLDWDM,BGQZLDWMC,BGQQSDWDM,BGQQSDWMC".Contains(field.Name.ToUpper()))
{
if (pf.Value[i].ToTrim() != pf.Value[bghIdx].ToTrim())
{
UnEqualAttr += field.Name.ToUpper() + ",";
}
continue;
}
if (!Equals(pf.Value[i].ToTrim(), pf.Value[bghIdx].ToTrim()))
{
result = false;
break;
}
}
return result;
}
///<summary>
/// 移除前缀字符串
///</summary>
///<param name="val">原字符串</param>
///<param name="str">前缀字符串</param>
///<returns></returns>
public string GetRemovePrefixString(string val, string str)
{
string strRegex = @"^(" + str + ")";
return Regex.Replace(val, strRegex, "");
}
/// <summary>
/// 获取更新过程数据
/// </summary>
/// <param name="pBGFeature">勾选得变更数据</param>
/// <param name="pJC_Layer">基础_地类图斑/行政区调整前基础图斑</param>
/// <param name="pGXGC_Layer">地类图斑更新过程层</param>
/// <param name="pGX_Layer">地类图斑更新层</param>
/// <returns></returns>
private List<DLTBGXAttribute> GetGXGCData2(IFeature pGXFeature, IFeatureLayer pJC_Layer, IFeatureLayer pGXGC_Layer, IFeatureLayer pGX_Layer)
{
try
{
//当前更新图斑pGXFeature
DLTBGXAttribute Save_GXData = new DLTBGXAttribute(gx_FieldsIndex);
Save_GXData.SetAttribure(pGXFeature);
Save_GXData.InheritOID = pGXFeature.OID;
Save_GXData.Shape2 = pGXFeature.ShapeCopy;
IQueryFilter queryFilter = new QueryFilterClass();
ITable tableGXGC = pGXGC_Layer.FeatureClass as ITable;
int BSMGXIndex = pGX_Layer.FeatureClass.FindField("BSM");
#region 从更新层里判断（判断该图斑是否压盖其他更新图斑）
List<IFeature> gx_Features = FeatureAPI.Identify(pGXFeature.ShapeCopy, pGX_Layer);
if (gx_Features.Count != 0)
{
foreach (var gxItem_ZB in gx_Features)//ZB-周边
{
if (gxItem_ZB.OID == pGXFeature.OID) continue;//压盖到自身
DLTBGXAttribute tempGX_ZB = new DLTBGXAttribute(gx_FieldsIndex)
{
UpdateOID = gxItem_ZB.OID,
InheritOID = gxItem_ZB.OID,
IsUpdate = true
};
tempGX_ZB.SetAttribure(gxItem_ZB);
tempGX_ZB.Shape2 = gxItem_ZB.ShapeCopy;
if (FeatureAPI.IsAdjacent(gxItem_ZB.ShapeCopy, pGXFeature.ShapeCopy))
{
if (tempGX_ZB.IsEqual(Save_GXData))//是否相邻比对属性数据
{
queryFilter.WhereClause = string.Format("BGHTBBSM='{0}'", gxItem_ZB.Value[BSMGXIndex].ToString().Trim());
tableGXGC.DeleteSearchedRows(queryFilter);
gxItem_ZB.Delete();//合并周边更新图斑（过程层？删除）
Save_GXData.Shape2 = FeatureAPI.Union(tempGX_ZB.Shape2, Save_GXData.Shape2);
Save_GXData.TBMJ += tempGX_ZB.TBMJ;
}
}
else if (FeatureAPI.IsContains(pGXFeature.ShapeCopy, gxItem_ZB.ShapeCopy))
{
queryFilter.WhereClause = string.Format("BGHTBBSM='{0}'", gxItem_ZB.Value[BSMGXIndex].ToString().Trim());
tableGXGC.DeleteSearchedRows(queryFilter);
gxItem_ZB.Delete();
}
else if (FeatureAPI.IsInterSect(gxItem_ZB.ShapeCopy, pGXFeature.ShapeCopy))
{
if (tempGX_ZB.IsEqual(Save_GXData))//相交且属性相同
{
Save_GXData.Shape2 = FeatureAPI.Union(tempGX_ZB.Shape2, Save_GXData.Shape2);
Save_GXData.TBMJ += tempGX_ZB.TBMJ;
queryFilter.WhereClause = string.Format("BGHTBBSM='{0}'", gxItem_ZB.Value[BSMGXIndex].ToString().Trim());
tableGXGC.DeleteSearchedRows(queryFilter);
gxItem_ZB.Delete();
}
else
{
tempGX_ZB.Shape2 = FeatureAPI.Difference(tempGX_ZB.Shape2, Save_GXData.Shape2);//留存的部分
if (!tempGX_ZB.Shape2.IsEmpty)
{
List<IGeometry> subGX_Items = FeatureAPI.DissolveGeometryByRing(tempGX_ZB.Shape2);
foreach (var item in subGX_Items)
{
if (subGX_Items.IndexOf(item) == 0)
{
tempGX_ZB.Shape2 = item;
tempGX_ZB.InheritOID = gxItem_ZB.OID;
gxDataList.Add(tempGX_ZB);
continue;
}
tempGX_ZB = new DLTBGXAttribute(gx_FieldsIndex);
tempGX_ZB.SetAttribure(gxItem_ZB);
tempGX_ZB.Shape2 = item;
tempGX_ZB.IsAdd = true;
gxDataList.Add(tempGX_ZB);
}
}
}
}
}
}
gxDataList.Add(Save_GXData);//若是更新层没有数据
foreach (DLTBGXAttribute gxItem in gxDataList)//当前更新层周边基础库(未发生变更的)，是否产生合并情况
{
List<IFeature> jc_Features = FeatureAPI.Identify(gxItem.Shape2, pJC_Layer);
foreach (var jc in jc_Features)
{
DLTBGXAttribute jcData = new DLTBGXAttribute(gx_FieldsIndex);
jcData.SetAttribure(jc, jc_FieldsIndex);
if (FeatureAPI.IsAdjacent(gxItem.Shape2, jc.ShapeCopy))
{
if (gxItem.IsEqual(jcData))
{
List<IFeature> list = FeatureAPI.Identify2(jc.ShapeCopy, pGX_Layer);
if (list.Count > 0) continue;
gxItem.Shape2 = FeatureAPI.Union(gxItem.Shape2, jc.ShapeCopy);
}
}
}
}
List<DLTBGXAttribute> newGXDataList = new List<DLTBGXAttribute>();
//压盖到其他更新图斑，经过一系列操作，产生新的更新图斑（被动变更）
foreach (DLTBGXAttribute gxItem in gxDataList)//根据更新图斑获取更新过程数据
{
gxItem.GCDataList.AddRange(GetGXGCData(gxItem, gxItem.Shape2, pGXGC_Layer, pJC_Layer, ref newGXDataList));//已存在的过程数据
if (gxItem.Shape == null)//从基础库获取过程数据
{
gxItem.GCDataList.AddRange(GetGXGCDataForJCLayer(gxItem, gxItem.Shape2, pJC_Layer, ref newGXDataList));
}
IRelationalOperator relational = gxItem.Shape as IRelationalOperator;
if (!relational.Equals(gxItem.Shape2))
{
List<DLTBGXGCAttribute> gcList = GetGXGCDataForJCLayer(gxItem, FeatureAPI.Difference(gxItem.Shape2, gxItem.Shape), pJC_Layer, ref newGXDataList);
foreach (var gc in gcList)
{
if (FeatureAPI.IsInterSect(gxItem.Shape, gc.Shape) || FeatureAPI.IsInterSect(gc.Shape, gxItem.Shape))
continue;
gxItem.GCDataList.Add(gc);
}
}
}
//擦除（更新）和相交（过程）的是否相交的部分
foreach (DLTBGXAttribute item in newGXDataList)
{
if (item.GCDataList.Count > 0)
{
if (gxDataList.FirstOrDefault(f => FeatureAPI.IsInterSect(f.Shape2, item.Shape)) == null)
{
gxDataList.Add(item);
}
}
}
#endregion
if (gxDataList.Count > 1)//多个更新数据
{
gxDataList = gxDataList.OrderByDescending(f => f.TBMJ).ToList();
List<DLTBGXAttribute> result = new List<DLTBGXAttribute>();
foreach (var item in gxDataList)
{
if (item.Shape == null)
continue;
if (item.GCDataList.Count == 1)//更新对应一个过程层
{
List<IFeature> jc_Features = new List<IFeature>();
jc_Features = FeatureAPI.Identify2(item.GCDataList[0].Shape, pJC_Layer);
if (jc_Features.Count == 1)
{
IRelationalOperator relational = item.GCDataList[0].Shape as IRelationalOperator;
if (relational.Equals(jc_Features[0].ShapeCopy))//属性变化（过程数据与基础库数据图形相同）
{
item.GCDataList[0].BGXW = "1";
item.BSM = jc_Features[0].Value[jc_Features[0].Fields.FindField("BSM")].ToTrim();
item.GCDataList[0].BGHTBBSM = item.BSM;
item.TBBH = jc_Features[0].Value[jc_Features[0].Fields.FindField("TBBH")].ToTrim();
result.Add(item);
continue;
}
}
}
ShapeInfo InterShape = new ShapeInfo(item.Shape);
DLTBAreaHandle InterHandle = new DLTBAreaHandle(InterShape);
List<ShapeInfo> InterShapes = InterHandle.GetFeatures();
if (InterShapes.Count > 1)
{
foreach (var subItem in InterShapes)
{
DLTBGXAttribute gx = new DLTBGXAttribute(gx_FieldsIndex, item.GCDataList[0]);
if (InterShapes.IndexOf(subItem) == 0)
{
gx.UpdateOID = item.UpdateOID;
gx.IsUpdate = item.IsUpdate;
}
else
{
gx.IsUpdate = false;
}
gx.GCDataList.AddRange(item.GCDataList.FindAll(f => FeatureAPI.IsContains(subItem.Shape, f.Shape)));
gx.BSM = "";
gx.TBBH = "";
gx.GCDataList.ForEach(f =>
{
if (f.IsUpdate && !string.IsNullOrWhiteSpace(f.BGHTBBSM))
{
gx.TBBH = f.BGHTBBH;
gx.BSM = f.BGHTBBSM;
}
f.BGXW = "2";
});
if (string.IsNullOrWhiteSpace(gx.BSM))
{
gx.IsUpdate = false;
}
if (gx.GCDataList.Count > 1 && !gx.IsUpdate)
gx.BSM = "";
result.Add(gx);
}
}
else
{
if (result.Count == 0)
{
result.Add(item);
}
else
{
if (result.FirstOrDefault(f => FeatureAPI.IsContains(f.Shape, item.Shape)) != null)
{
continue;
}
else
{
if (result.FirstOrDefault(f => f.BSM == item.BSM) != null)
{
item.BSM = "";
item.GCDataList.ForEach(f => f.BGHTBBSM = "");
}
result.Add(item);
}
}
item.GCDataList.ForEach(f =>
{
f.BGHTBBH = item.TBBH;
f.BGHTBBSM = item.BSM;
f.BGXW = "2";
});
}
}
return result;
}
if (gxDataList.Count == 1)
{
if (gxDataList[0].GCDataList.Count == 1)
{
List<IFeature> jc_Features = new List<IFeature>();
jc_Features = FeatureAPI.Identify2(gxDataList[0].GCDataList[0].Shape, pJC_Layer);
if (jc_Features.Count == 1)
{
IRelationalOperator relational = gxDataList[0].GCDataList[0].Shape as IRelationalOperator;
if (relational.Equals(jc_Features[0].ShapeCopy))//属性变化（过程数据与基础库数据图形相同）
{
gxDataList[0].GCDataList[0].BGXW = "1";
gxDataList[0].BSM = jc_Features[0].Value[jc_Features[0].Fields.FindField("BSM")].ToTrim();
gxDataList[0].GCDataList[0].BGHTBBSM = gxDataList[0].BSM;
gxDataList[0].TBBH = jc_Features[0].Value[jc_Features[0].Fields.FindField("TBBH")].ToTrim();
}
else
{
gxDataList[0].GCDataList[0].BGHTBBSM = gxDataList[0].BSM;
gxDataList[0].GCDataList[0].BGXW = "2";
}
}
}
else
{
gxDataList[0].GCDataList.ForEach(f =>
{
f.BGXW = "2";
f.BGHTBBSM = gxDataList[0].BSM;
});
}
}
return gxDataList;
}
catch (Exception ex)
{
LogAPI.Debug(ex.Message);
throw ex;
}
}
/// <summary>
/// 获取字段名称及下标值
/// </summary>
/// <param name="pFields">要素类字段集合</param>
/// <returns></returns>
private Dictionary<string, int> GetFieldsIndex(IFields pFields)
{
Dictionary<string, int> result = new Dictionary<string, int>();
for (int i = 0; i < pFields.FieldCount; i++)
{
IField field = pFields.Field[i];
if (!field.Editable || field.Name.ToUpper().Contains("SHAPE") || field.Name.ToUpper() == "SJNF") continue;
result.Add(field.Name.ToUpper(), i);
Marshal.ReleaseComObject(field);
}
return result;
}
/// <summary>
/// 从更新过程层获取过程数据
/// </summary>
/// <param name="pBGFeature">勾选的变更数据</param>
/// <param name="pGXShape">变更图形</param>
/// <param name="pGXGC_Layer"></param>
/// <param name="pJC_Layer"></param>
/// <param name="newGXData"></param>
/// <returns></returns>
private List<DLTBGXGCAttribute> GetGXGCData(DLTBGXAttribute pBGFeature, IGeometry pGXShape, IFeatureLayer pGXGC_Layer, IFeatureLayer pJC_Layer, ref List<DLTBGXAttribute> newGXData)
{
List<DLTBGXGCAttribute> result = new List<DLTBGXGCAttribute>();
//foreach (var gx in newGXData)
int gxCount = newGXData.Count;
for (int num = 0; num < gxCount; num++)
{
var gx = newGXData[num];
foreach (var gc in gx.GCDataList)
{
if (FeatureAPI.IsContains(gc.Shape, pGXShape))
{
double jc_MJ = gc.BGMJ;
//相交部分图形
IGeometry IntersectGeo = FeatureAPI.InterSect(gc.Shape, pGXShape);
if (IntersectGeo.IsEmpty)
continue;
#region 图斑分割/合并/拆分多部件后进行面积平差
List<DLTBGXGCAttribute> Area_GXGCAttribure = new List<DLTBGXGCAttribute>();
ShapeInfo InterShape = new ShapeInfo(IntersectGeo);
DLTBAreaHandle InterHandle = new DLTBAreaHandle(InterShape);
List<ShapeInfo> InterShapes = InterHandle.GetFeatures();
List<ShapeInfo> areaOperationData = new List<ShapeInfo>();
int id = 0;
foreach (var item in InterShapes)
{
id++;
item.ID = id;
areaOperationData.Add(item);
}
IGeometry DiffGeo = FeatureAPI.Difference(gc.Shape, pGXShape);
List<ShapeInfo> DiffShapes = null;
if (DiffGeo != null && !DiffGeo.IsEmpty)
{
ShapeInfo DiffShape = new ShapeInfo(DiffGeo);
DLTBAreaHandle DiffHandle = new DLTBAreaHandle(DiffShape);
DiffShapes = DiffHandle.GetFeatures();
foreach (var item in DiffShapes)
{
id++;
item.ID = id;
areaOperationData.Add(item);
}
}
AreaAdjustment2(areaOperationData, jc_MJ);
foreach (var item in areaOperationData)
{
if (InterShapes != null)
{
if (InterShapes.FirstOrDefault(f => f.ID == item.ID) != null)
{
InterShapes.FirstOrDefault(f => f.ID == item.ID).SetArea(item.Area);
}
else if (DiffShapes != null)
{
if (DiffShapes.FirstOrDefault(f => f.ID == item.ID) != null)
{
DiffShapes.FirstOrDefault(f => f.ID == item.ID).SetArea(item.Area);
}
}
}
}
#endregion
for (int i = 0; i < InterShapes.Count; i++)
{
DLTBGXGCAttribute gxgc2 = new DLTBGXGCAttribute(gxgc_FieldsIndex);
gxgc2.SetBGQAttribure(gc);
gxgc2.SetBGHAttribure(pBGFeature);
gxgc2.BGMJ = InterShapes[i].Area;
if (i == 0)
{
gxgc2.Shape = InterShapes[i].Shape;
result.Add(gxgc2);
}
else
{
gc.BGMJ = InterShapes[i].Area;
gc.Shape = InterShapes[i].Shape;
}
}
if (DiffShapes != null)
{
for (int j = 0; j < DiffShapes.Count; j++)
{
if (j == 0)
{
gc.Shape = DiffShapes[j].Shape;
gc.BGMJ = DiffShapes[j].Area;
}
else
{
DLTBGXGCAttribute gxgc2 = new DLTBGXGCAttribute(gxgc_FieldsIndex);
gxgc2.SetBGQAttribure(gc);
gxgc2.SetBGHAttribure(pBGFeature);
gxgc2.Shape = DiffShapes[j].Shape;
gxgc2.BGMJ = DiffShapes[j].Area;
DLTBGXAttribute newGXData3 = new DLTBGXAttribute(gx_FieldsIndex, gxgc2)
{
BSM = gc.BGHTBBSM
};
newGXData3.GCDataList.Add(gxgc2);
newGXData.Add(newGXData3);
}
}
}
else
{
gx.GCDataList.Remove(gc);
}
break;
}
else if (FeatureAPI.GetEqual(gc.Shape, pGXShape) || FeatureAPI.IsContains(pGXShape, gc.Shape))
{
gc.SetBGHAttribure(pBGFeature);
result.Add(gc);
gx.GCDataList.Remove(gc);
break;
}
else
{
double jc_MJ = gc.BGMJ;
//相交部分图形
IGeometry IntersectGeo = FeatureAPI.InterSect(gc.Shape, pGXShape);
if (IntersectGeo.IsEmpty)
continue;
#region 图斑分割/合并/拆分多部件后进行面积平差
List<DLTBGXGCAttribute> Area_GXGCAttribure = new List<DLTBGXGCAttribute>();
ShapeInfo InterShape = new ShapeInfo(IntersectGeo);
DLTBAreaHandle InterHandle = new DLTBAreaHandle(InterShape);
List<ShapeInfo> InterShapes = InterHandle.GetFeatures();
List<ShapeInfo> areaOperationData = new List<ShapeInfo>();
int id = 0;
foreach (var item in InterShapes)
{
id++;
item.ID = id;
areaOperationData.Add(item);
}
IGeometry DiffGeo = FeatureAPI.Difference(gc.Shape, pGXShape);
List<ShapeInfo> DiffShapes = null;
if (DiffGeo != null && !DiffGeo.IsEmpty)
{
ShapeInfo DiffShape = new ShapeInfo(DiffGeo);
DLTBAreaHandle DiffHandle = new DLTBAreaHandle(DiffShape);
DiffShapes = DiffHandle.GetFeatures();
foreach (var item in DiffShapes)
{
id++;
item.ID = id;
areaOperationData.Add(item);
}
}
AreaAdjustment2(areaOperationData, jc_MJ);
foreach (var item in areaOperationData)
{
if (InterShapes != null)
{
if (InterShapes.FirstOrDefault(f => f.ID == item.ID) != null)
{
InterShapes.FirstOrDefault(f => f.ID == item.ID).SetArea(item.Area);
}
else if (DiffShapes != null)
{
if (DiffShapes.FirstOrDefault(f => f.ID == item.ID) != null)
{
DiffShapes.FirstOrDefault(f => f.ID == item.ID).SetArea(item.Area);
}
}
}
}
#endregion
for (int i = 0; i < InterShapes.Count; i++)
{
DLTBGXGCAttribute gxgc2 = new DLTBGXGCAttribute(gxgc_FieldsIndex);
gxgc2.SetBGQAttribure(gc);
gxgc2.SetBGHAttribure(pBGFeature);
gxgc2.BGMJ = InterShapes[i].Area;
if (i == 0)
{
IRelationalOperator relational = InterShapes[i].Shape as IRelationalOperator;
if (result.Count > 0)
{
bool x = false;
foreach (var item in result)
{
if (relational.Equals(item.Shape))
{
x = true;
}
}
if (!x)
{
gxgc2.Shape = InterShapes[i].Shape;
result.Add(gxgc2);
}
}
else
{
gxgc2.Shape = InterShapes[i].Shape;
result.Add(gxgc2);
}
}
else
{
gc.BGMJ = InterShapes[i].Area;
gc.Shape = InterShapes[i].Shape;
}
}
if (DiffShapes != null)
{
for (int j = 0; j < DiffShapes.Count; j++)
{
if (j == 0)
{
gc.Shape = DiffShapes[j].Shape;
gc.BGMJ = DiffShapes[j].Area;
}
else
{
DLTBGXGCAttribute gxgc2 = new DLTBGXGCAttribute(gxgc_FieldsIndex);
gxgc2.SetBGQAttribure(gc);
gxgc2.SetBGHAttribure(pBGFeature);
gxgc2.Shape = DiffShapes[j].Shape;
gxgc2.BGMJ = DiffShapes[j].Area;
DLTBGXAttribute newGXData3 = new DLTBGXAttribute(gx_FieldsIndex, gxgc2);
newGXData3.BSM = gc.BGHTBBSM;
newGXData3.GCDataList.Add(gxgc2);
newGXData.Add(newGXData3);
}
//gc.Shape = DiffShapes[j].Shape;
//gc.BGMJ = DiffShapes[j].Area;
}
}
break;
}
}
gxCount = newGXData.Count;
}
List<IFeature> gxgc_Features = FeatureAPI.Identify2(pGXShape, pGXGC_Layer);
foreach (IFeature gxgcItem in gxgc_Features)
{
if (result.FirstOrDefault(f => FeatureAPI.IsInterSect(f.Shape, gxgcItem.ShapeCopy)) != null)
{ gxgcItem.Delete(); continue; }//变更层生成更新层数据相交到过程层数据直接略过
DLTBGXGCAttribute gxgc = new DLTBGXGCAttribute(gxgc_FieldsIndex);
gxgc.SetAttribure(gxgcItem, gxgc_FieldsIndex);
gxgc.Shape = gxgcItem.ShapeCopy;
gxgc.IsUpdate = true;
gxgc.UpdateOID = gxgcItem.OID;
gxgc.BGMJ = gxgcItem.Value[gxgcItem.Fields.FindField("TBBGMJ")].ToDouble();
//扩张的更新数据
if (FeatureAPI.GetEqual(pGXShape, gxgcItem.ShapeCopy))
{//更新层与过程层图形是否相等/包含
List<IFeature> jc_Features = FeatureAPI.Identify2(pGXShape, pJC_Layer);
if (jc_Features.Count == 1 && FeatureAPI.Difference(jc_Features[0].ShapeCopy, gxgcItem.ShapeCopy).IsEmpty)
{
gxgc.BGHTBBSM = jc_Features[0].Value[jc_Features[0].Fields.FindField("BSM")].ToString();
gxgc.BGHTBBH = jc_Features[0].Value[jc_Features[0].Fields.FindField("TBBH")].ToString();
}
result.Add(gxgc);
}
else if (FeatureAPI.IsContains(pGXShape, gxgcItem.ShapeCopy))
{
List<IFeature> jc_Features = FeatureAPI.Identify2(gxgcItem.ShapeCopy, pJC_Layer);
IGeometry geomey = FeatureAPI.InterSect(jc_Features[0].ShapeCopy, pGXShape);
if (jc_Features.Count == 1 && !FeatureAPI.Difference(geomey, gxgcItem.ShapeCopy).IsEmpty)
{
gxgc.Shape = geomey;
gxgc.BGMJ = pBGFeature.TBMJ;
result.Add(gxgc);
}
else if (FeatureAPI.GetEqual(geomey, gxgcItem.ShapeCopy))
{
gxgc.BGMJ = pBGFeature.TBMJ;
gxgc.BGHTBBSM = pBGFeature.BSM;
result.Add(gxgc);
}
}
else
{
double jc_MJ = gxgc.BGMJ;
//相交部分图形
IGeometry IntersectGeo = FeatureAPI.InterSect(gxgcItem.ShapeCopy, pGXShape);
#region 图斑分割/合并/拆分多部件后进行面积平差
List<DLTBGXGCAttribute> Area_GXGCAttribure = new List<DLTBGXGCAttribute>();
ShapeInfo InterShape = new ShapeInfo(IntersectGeo);
DLTBAreaHandle InterHandle = new DLTBAreaHandle(InterShape);
List<ShapeInfo> InterShapes = InterHandle.GetFeatures();
List<ShapeInfo> areaOperationData = new List<ShapeInfo>();
int id = 0;
foreach (var item in InterShapes)
{
id++;
item.ID = id;
areaOperationData.Add(item);
}
IGeometry DiffGeo = FeatureAPI.Difference(gxgcItem.ShapeCopy, pGXShape);
List<ShapeInfo> DiffShapes = null;
if (DiffGeo != null && !DiffGeo.IsEmpty)
{
ShapeInfo DiffShape = new ShapeInfo(DiffGeo);
DLTBAreaHandle DiffHandle = new DLTBAreaHandle(DiffShape);
DiffShapes = DiffHandle.GetFeatures();
foreach (var item in DiffShapes)
{
id++;
item.ID = id;
areaOperationData.Add(item);
}
}
AreaAdjustment2(areaOperationData, jc_MJ);
foreach (var item in areaOperationData)
{
if (InterShapes != null)
{
if (InterShapes.FirstOrDefault(f => f.ID == item.ID) != null)
{
InterShapes.FirstOrDefault(f => f.ID == item.ID).SetArea(item.Area);
}
else if (DiffShapes != null)
{
if (DiffShapes.FirstOrDefault(f => f.ID == item.ID) != null)
{
DiffShapes.FirstOrDefault(f => f.ID == item.ID).SetArea(item.Area);
}
}
}
}
#endregion
for (int i = 0; i < InterShapes.Count; i++)
{
DLTBGXGCAttribute gxgc2 = new DLTBGXGCAttribute(gxgc_FieldsIndex);
gxgc2.SetAttribure(gxgcItem, gxgc_FieldsIndex);
gxgc2.SetBGHAttribure(pBGFeature);
gxgc2.BGMJ = InterShapes[i].Area;
gxgc2.Shape = InterShapes[i].Shape;
if (i == 0)
{
gxgc2.IsUpdate = true;
gxgc2.UpdateOID = gxgc.UpdateOID;
gxgc2.BGHTBBSM = gxgc.BGHTBBSM;
bool IsUnion = false;
foreach (DLTBGXGCAttribute itemGCNew in result)
{
if (FeatureAPI.IsAdjacent(itemGCNew.Shape, gxgc2.Shape) && itemGCNew.FieldsValue["BGQTBBSM"] == gxgc2.FieldsValue["BGQTBBSM"])
{
itemGCNew.UnionDLTBGXGCAttr(gxgc2);
IsUnion = true;
break;
}
}
if (IsUnion == false)
result.Add(gxgc2);
}
else
{
result.Add(gxgc2);
continue;
}
}
List<IFeature> jc_Features = FeatureAPI.Identify(gxgcItem.ShapeCopy, pJC_Layer);
for (int j = 0; j < DiffShapes.Count; j++)
{
IFeature GX_f = _curDLTBGX_FL.FeatureClass.GetFeature(SaveFeatureOID);
IFeature JC_F = jc_Features.FirstOrDefault(x => x.Value[pJC_Layer.FeatureClass.FindField("BSM")].ToString() == gxgc.FieldsValue["BGQTBBSM"].ToString());
if (JC_F == null || GX_f.Value[_curDLTBGX_FL.FeatureClass.FindField("BSM")].ToString() != pBGFeature.BSM) continue;
DLTBGXGCAttribute gxgc2 = new DLTBGXGCAttribute(gxgc_FieldsIndex);
//额外增量数据赋值
gxgc2.Shape = DiffShapes[j].Shape;
gxgc2.SetAttribure(gxgcItem, gxgc_FieldsIndex);//更新图斑外扩
if (gxgc.BGHTBBSM == pBGFeature.BSM)//更新图斑内缩
{
gxgc2.SetBGHAttribure(JC_F, jc_FieldsIndex);
List<IFeature> gc_Features = FeatureAPI.Identify(gxgc2.Shape, _curDLTBGXGC_FL);
bool isUnioned = false;
for (int i = 0; i < gc_Features.Count; i++)//内缩被动变更操作
{
if (FeatureAPI.IsAdjacent(gxgc2.Shape, gc_Features[i].ShapeCopy) && !FeatureAPI.IsInterSect(gxgc2.Shape, gc_Features[i].ShapeCopy))
{
DLTBGXGCAttribute dLTBGXGC = new DLTBGXGCAttribute(gxgc_FieldsIndex);
dLTBGXGC.SetAttribure(gc_Features[i], gxgc_FieldsIndex);
dLTBGXGC.Shape = gc_Features[i].ShapeCopy;
if (dLTBGXGC.BGHAttribureIsEqual(gxgc2))
{
int GCBGMJ = _curDLTBGXGC_FL.FeatureClass.FindField("TBBGMJ");
int GXBGMJ = _curDLTBGX_FL.FeatureClass.FindField("TBMJ");
int GXBSM = _curDLTBGX_FL.FeatureClass.FindField("BSM");
gc_Features[i].Value[GCBGMJ] = Convert.ToDouble(gc_Features[i].Value[GCBGMJ]) + DiffShapes[j].Area;
List<IFeature> GX_Fs = FeatureAPI.Identify2(gc_Features[i].ShapeCopy, _curDLTBGX_FL);
GX_Fs[0].Shape = FeatureAPI.Union(gxgc2.Shape, GX_Fs[0].ShapeCopy);
if (GXBGMJ != -1)
GX_Fs[0].Value[GXBGMJ] = Convert.ToDouble(GX_Fs[0].Value[GXBGMJ]) + DiffShapes[j].Area;
GX_Fs[0].Store();
gc_Features[i].Shape = FeatureAPI.Union(gxgc2.Shape, gc_Features[i].ShapeCopy);
gc_Features[i].Store();
isUnioned = true;
}
}
}
if (isUnioned == true) continue;
}
gxgc2.BGMJ = DiffShapes[j].Area;
DLTBGXAttribute newGXData3 = new DLTBGXAttribute(gx_FieldsIndex, gxgc2)
{
BSM = gxgc.BGHTBBSM,
Shape2 = gxgc2.Shape
};
newGXData3.GCDataList.Add(gxgc2);
if (FeatureAPI.IsAdjacent(pGXShape, newGXData3.Shape) && pBGFeature.IsEqual(newGXData3))
{
result.Add(gxgc2);
}
else
newGXData.Add(newGXData3);
}
}
gxgcItem.Delete();
}
return result;
}
private List<DLTBGXGCAttribute> GetGXGCDataForJCLayer(DLTBGXAttribute pBGFeature, IGeometry pGXShape, IFeatureLayer pJC_Layer, ref List<DLTBGXAttribute> newGXData)
{
List<DLTBGXGCAttribute> result = new List<DLTBGXGCAttribute>();
List<IFeature> jc_Features = new List<IFeature>();
jc_Features = FeatureAPI.Identify(pGXShape, pJC_Layer);
foreach (var jc in jc_Features)
{
DLTBGXGCAttribute gxgc = new DLTBGXGCAttribute(gxgc_FieldsIndex);
//gxgc.BGTBOID = pBGFeature.OID.ToString();
gxgc.SetBGQAttribure(jc, jc_FieldsIndex);
gxgc.SetBGHAttribure(jc, jc_FieldsIndex);
gxgc.BGMJ = jc.Value[jc.Fields.FindField("TBMJ")].ToDouble();
gxgc.BGHTBBH = jc.Value[jc.Fields.FindField("TBBH")].ToTrim();
if (FeatureAPI.IsAdjacent(jc.ShapeCopy, pGXShape))
{
DLTBGXAttribute tempgx = new DLTBGXAttribute(gx_FieldsIndex);
tempgx.SetAttribure(jc, jc_FieldsIndex);
if (pBGFeature.IsEqual(tempgx))
{
gxgc.Shape = jc.ShapeCopy;
result.Add(gxgc);
}
}
else if (FeatureAPI.IsContains(pGXShape, jc.ShapeCopy))
{
gxgc.Shape = jc.ShapeCopy;
gxgc.SetBGHAttribure(pBGFeature);
if (pBGFeature.FieldsValue.ContainsKey("XZQTZLX"))
{
gxgc.SetXZQTZLX(pBGFeature.FieldsValue["XZQTZLX"].ToTrim());
}
if (FeatureAPI.IsContains(jc.ShapeCopy, pGXShape))
{
gxgc.BGHTBBSM = jc.Value[jc.Fields.FindField("BSM")].ToTrim();
}
result.Add(gxgc);
}
else
{
double jc_MJ = gxgc.BGMJ;
//相交部分图形
IGeometry IntersectGeo = FeatureAPI.InterSect(jc.ShapeCopy, pGXShape);
if (IntersectGeo.IsEmpty || IntersectGeo.GetEllipseArea() <= 0.1)
continue;
#region 图斑分割/合并/拆分多部件后进行面积平差
List<DLTBGXGCAttribute> Area_GXGCAttribure = new List<DLTBGXGCAttribute>();
ShapeInfo InterShape = new ShapeInfo(IntersectGeo);
DLTBAreaHandle InterHandle = new DLTBAreaHandle(InterShape);
List<ShapeInfo> InterShapes = InterHandle.GetFeatures();
List<ShapeInfo> areaOperationData = new List<ShapeInfo>();
int id = 0;
foreach (var item in InterShapes)
{
id++;
item.ID = id;
areaOperationData.Add(item);
}
IGeometry DiffGeo = FeatureAPI.Difference(jc.ShapeCopy, pGXShape);
List<ShapeInfo> DiffShapes = null;
if (DiffGeo != null && !DiffGeo.IsEmpty)
{
ShapeInfo DiffShape = new ShapeInfo(DiffGeo);
DLTBAreaHandle DiffHandle = new DLTBAreaHandle(DiffShape);
DiffShapes = DiffHandle.GetFeatures();
foreach (var item in DiffShapes)
{
id++;
item.ID = id;
areaOperationData.Add(item);
}
}
AreaAdjustment2(areaOperationData, jc_MJ);//过程数据平差
foreach (var item in areaOperationData)
{
if (InterShapes != null)
{
if (InterShapes.FirstOrDefault(f => f.ID == item.ID) != null)
{
InterShapes.FirstOrDefault(f => f.ID == item.ID).SetArea(item.Area);
}
else if (DiffShapes != null)
{
if (DiffShapes.FirstOrDefault(f => f.ID == item.ID) != null)
{
DiffShapes.FirstOrDefault(f => f.ID == item.ID).SetArea(item.Area);
}
}
}
}
#endregion
foreach (var item in InterShapes)//return 过程数据
{
DLTBGXGCAttribute gxgc2 = new DLTBGXGCAttribute(gxgc_FieldsIndex);
gxgc2.SetBGQAttribure(jc, jc_FieldsIndex);
gxgc2.SetBGHAttribure(pBGFeature);
gxgc2.BGMJ = item.Area;
gxgc2.Shape = item.Shape;
result.Add(gxgc2);
}
for (int j = 0; j < DiffShapes.Count; j++)//ref newGXData更新数据
{
if (FeatureAPI.Identify2(DiffShapes[j].Shape, _curDLTBGX_FL).Count <= 0)//被动变更部分
{ //验证当前是切割的，还是被动变更部分
DLTBGXGCAttribute gxgc2 = new DLTBGXGCAttribute(gxgc_FieldsIndex);
gxgc2.SetBGQAttribure(jc, jc_FieldsIndex);
gxgc2.SetBGHAttribure(jc, jc_FieldsIndex);
string bsmPrefix = MaxBSM.Substring(0, 10);
int MaxNum = Convert.ToInt32(MaxBSM.Substring(9));
MaxBSM = bsmPrefix + (MaxNum + 1).ToString().PadLeft(8, '0');
gxgc2.BGHTBBSM = MaxBSM;
gxgc2.Shape = DiffShapes[j].Shape;
gxgc2.BGMJ = DiffShapes[j].Area;
DLTBGXAttribute newGXData3 = new DLTBGXAttribute(gx_FieldsIndex, gxgc2);
newGXData3.BSM = gxgc2.BGHTBBSM;
//newGXData3.TBBH = gxgc.BGHTBBH;
newGXData3.GCDataList.Add(gxgc2);
newGXData.Add(newGXData3);
}
}
}
}
return result;
}
/// <summary>
/// 面积平差
/// </summary>
/// <param name="shpList">需要平差的对象集合</param>
/// <param name="pKZMJ">控制面积</param>
public void AreaAdjustment2(List<ShapeInfo> shpList, double pKZMJ)
{
if (shpList.Count == 1)
{
shpList[0].SetArea(pKZMJ);
return;
}
//如果面积=0，计算椭球面积
shpList.ForEach(f =>
{
if (f.Area == 0)
f.CalculationArea();
});
shpList = shpList.OrderByDescending(o => o.Area).ToList();
double mjc = Math.Round(shpList.Sum(s => s.Area) - pKZMJ, 2);
//平差
while (Math.Round(mjc, 2) != 0)
{
int tpsm = (int)(Math.Abs(Math.Round(mjc, 2)) / (double)0.01);
int e = tpsm / shpList.Count;
int f = tpsm % shpList.Count;
if (f != 0)
{
double tpmj = (e + 1) * 0.01;
for (int i = 0; i < f; i++)
{
if (mjc < 0)
shpList[i].SetArea(shpList[i].Area + tpmj);
else
shpList[i].SetArea(shpList[i].Area - tpmj);
}
}
if (e != 0)
{
double tpmj = e * 0.01;
for (int i = f; i < shpList.Count; i++)
{
if (mjc < 0)
shpList[i].SetArea(shpList[i].Area + tpmj);
else
shpList[i].SetArea(shpList[i].Area - tpmj);
}
}
mjc = Math.Round(shpList.Sum(s => s.Area), 2) - pKZMJ;
}
}
private void InitView()
{
if (_Elements == null)
_Elements = BundleRuntime.Instance.GetService<IElementInfo>();
if (_FeatureInfo == null && _Elements != null)
_FeatureInfo = _Elements.FirstOrDefault(f => f.Title == "要素属性");
if ((_FeatureInfo as UserControl).Parent != null)
((_FeatureInfo as UserControl).Parent as Grid).Children.Clear();
if (_FeatureInfo != null)
TBInfo.Children.Add(_FeatureInfo as UIElement);
}
public void ShowPanel()
{
Platform.Instance.OpenView(this, false);
}
public void ClosePanel()
{
_FeatureInfo.BindData(null);
_FeatureInfo = null;
MapsManager.Instance.MapService.OnSelectionChanged -= MapService_OnSelectionChanged;
Platform.Instance.CloseView(this);
}
public void ClosePanelInvoke()
{
CloseViewHandler?.Invoke(this, null);
}
}
}