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.
1 Commit
4 Branches
0 Tags
121 MiB
 
 
Tag: Branch: Tree: Dev
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'Dev'
${ noResults }
NDBGJK5.0/Kingo.Plugins/Kingo.Plugin.EngineEditor/Commands/Tools/ControlsEditingDrawLineToPo...

3844 lines
173 KiB
Raw Permalink Blame History

using ESRI.ArcGIS.ADF.BaseClasses;
using ESRI.ArcGIS.Carto;
using ESRI.ArcGIS.Controls;
using ESRI.ArcGIS.Display;
using ESRI.ArcGIS.esriSystem;
using ESRI.ArcGIS.Geodatabase;
using ESRI.ArcGIS.Geometry;
using KGIS.Framework.AE;
using KGIS.Framework.Maps;
using KGIS.Framework.Platform;
using KGIS.Framework.Utils;
using KGIS.Framework.Utils.Helper;
using Kingo.Plugin.EngineEditor.Common;
using Kingo.Plugin.EngineEditor.Model;
using Kingo.Plugin.EngineEditor.Views;
using Kingo.PluginServiceInterface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using UIShell.OSGi;
namespace Kingo.Plugin.EngineEditor.Commands.Tools
{
/// <summary>
/// 画线物面（线状地物面）工具
/// </summary>
public class ControlsEditingDrawLineToPolygonToolForKDB : BaseTool
{
//public KGIS.Common.Interface.IRegionAuthorize RegionAuthorize
//{
// get;
// set;
//}
public VerificationOfFeatureNodeDensity density
{
get;
set;
}
//RegionAuthorize RegionAuthorize = null;
private IEngineSnapEnvironment snapEnv = null;
#region 私有变量
//KOTilesLayer layer = null;
private EngineEditorClass m_editor;
private IHookHelper m_hookHelper;
/// <summary>
/// 平移工具
/// </summary>
private ControlsMapPanToolClass panTool = null;
/// <summary>
/// 中间线
/// </summary>
private LineModel MiddleLine;
/// <summary>
/// 左边线
/// </summary>
private LineModel LeftLine;
/// <summary>
/// 右边线
/// </summary>
private LineModel RightLine;
/// <summary>
/// 是否续画
/// </summary>
private bool IsContinueDraw = false;
/// <summary>
/// 续画左端点
/// </summary>
private IPoint ContinueDrawLeftPoint = null;
/// <summary>
/// 续画右端点
/// </summary>
private IPoint ContinueDrawRightPoint = null;
/// <summary>
/// 续画宽度
/// </summary>
private double ContinueDrawLength = 0.0;
private bool _IsDrawing;
/// <summary>
/// 正在绘制
/// </summary>
private bool IsDrawing
{
get
{
return _IsDrawing;
}
set
{
_IsDrawing = value;
if (_IsDrawing)
{
//替换Env改动
//Env.Instance.KMap.AxMapControl.AutoMouseWheel = false;
//Env.Instance.KMap.AxMapControl.AutoKeyboardScrolling = false;
(m_hookHelper.Hook as IMapControlDefault).AutoMouseWheel = false;
(m_hookHelper.Hook as IMapControlDefault).AutoKeyboardScrolling = false;
}
else
{
//替换Env改动
//Env.Instance.KMap.AxMapControl.AutoMouseWheel = true;
//Env.Instance.KMap.AxMapControl.AutoKeyboardScrolling = true;
(m_hookHelper.Hook as IMapControlDefault).AutoMouseWheel = true;
(m_hookHelper.Hook as IMapControlDefault).AutoKeyboardScrolling = true;
}
}
}
private Boolean IsSpaceDown = false;
private bool IsCtrlDown = false;
private IElement TextElement;
/// <summary>
/// 记录鼠标当前位置
/// </summary>
private System.Drawing.Point MousePoint = new System.Drawing.Point();
private bool IsChangedWidht = false;
/// <summary>
/// 道路线最小点间距
/// </summary>
private int MinPointDistance = 30;
/// <summary>
/// 道路线最大点间距
/// </summary>
private int MaxPointDistance = 80;
public DrawParam drawParam
{
get;
set;
}
FrmDrawDoublePolyline paramFrm = null;
private bool IsAutoTrackPoint
{
set
{
if (MiddleLine != null)
{
MiddleLine.IsAutoTrackPoint = value;
}
if (LeftLine != null)
{
LeftLine.IsAutoTrackPoint = value;
}
if (RightLine != null)
{
RightLine.IsAutoTrackPoint = value;
}
}
}
/// <summary>
/// 是否自动追踪
/// </summary>
private bool IsAuto = false;
#region 地图自动漫游相关变量
/// <summary>
/// 表示是否开启自动漫游功能
/// </summary>
private bool AllowMoveMap = false;
/// <summary>
/// 地图漫游计时器（表示多久移动一次地图）
/// </summary>
private System.Windows.Forms.Timer timer = null;
/// <summary>
/// 鼠标距离地图边界的距离（当小于指定值是开始漫游）
/// </summary>
private int MapBorderDistance = 10;
#endregion
#region 自动识别功能相关变量
/// <summary>
/// 自动识别计时器（相隔一定时间，根据鼠标位置自动识别一次）
/// </summary>
private System.Windows.Forms.Timer autoDistinguishTimer = null;
/// <summary>
/// 用于存放自动识别到的点元素集合
/// </summary>
private List<IElement> PointElement = new List<IElement>();
/// <summary>
/// 用于存放自动识别到的宽度
/// </summary>
private double TempWidht = 0;
/// <summary>
/// 用于临时存放自动识别到的中心点
/// </summary>
private IPoint TempCenterPoint = null;
#endregion
/// <summary>
/// 记录捕捉Element上点的索引
/// </summary>
private int SnapElementPointIndex = -1;
/// <summary>
/// 记录捕捉的点在哪条线上（0：中心线；1：左边线；-1：右边线）
/// </summary>
private int SnapElementPointLine = 0;
#endregion
/// <summary>
/// 初始化工具相关属性
/// </summary>
private void Init()
{
//初始化计时器
timer = new System.Windows.Forms.Timer();
timer.Interval = 100;
timer.Tick += timer_Tick;
autoDistinguishTimer = new System.Windows.Forms.Timer();
autoDistinguishTimer.Interval = 100;
autoDistinguishTimer.Tick += autoDistinguishTimer_Tick;
//初始化地图漫游工具
panTool = new ControlsMapPanToolClass();
panTool.OnCreate(m_hookHelper.Hook);
//初始化编辑对象
if (m_editor == null)
m_editor = new EngineEditorClass();// Env.Instance.KMap.EngEditor;
if (snapEnv == null)
snapEnv = m_editor;
//开启自动漫游功能
AllowMoveMap = false;
//注册鼠标滚轮事件
//替换Env改动
//Env.Instance.Platfrom.MapMouseWheel -= Platfrom_MapMouseWheel;
//Env.Instance.Platfrom.MapMouseWheel += Platfrom_MapMouseWheel;
if (_MapService != null)
{
_MapService.MapContainerMouseWheel -= Platfrom_MapMouseWheel;
_MapService.MapContainerMouseWheel += Platfrom_MapMouseWheel;
}
//白明雅 2020-04-07 用于激活键盘事件
MapsManager.Instance.MapService.getAxMapControl().Focus();
//初始化绘制模型
if (MiddleLine == null)
MiddleLine = new LineModel(m_hookHelper.ActiveView, esriSimpleLineStyle.esriSLSDash, 0.5);
if (LeftLine == null)
LeftLine = new LineModel(m_hookHelper.ActiveView, esriSimpleLineStyle.esriSLSSolid);
if (RightLine == null)
RightLine = new LineModel(m_hookHelper.ActiveView, esriSimpleLineStyle.esriSLSSolid);
MiddleLine.Init();
LeftLine.Init();
RightLine.Init();
//设置鼠标样式
base.m_cursor = System.Windows.Forms.Cursors.Cross;
//初始化其他参数
IsSpaceDown = false;
IsDeactivate = false;
if (PointElement == null)
PointElement = new List<IElement>();
}
/// <summary>
/// 释放工具相关对象
/// </summary>
private void Dispose()
{
//销毁计时器
if (timer != null)
{
timer.Tick -= timer_Tick;
timer.Stop();
timer.Dispose();
}
if (autoDistinguishTimer != null)
{
autoDistinguishTimer.Tick -= autoDistinguishTimer_Tick;
autoDistinguishTimer.Stop();
autoDistinguishTimer.Dispose();
}
//销毁panTool工具
if (panTool != null)
{
panTool.Deactivate();
Marshal.ReleaseComObject(panTool);
panTool = null;
}
//取消事件注册
//替换Env改动
//Env.Instance.Platfrom.MapMouseWheel -= Platfrom_MapMouseWheel;
if (_MapService != null)
{
_MapService.MapContainerMouseWheel -= Platfrom_MapMouseWheel;
}
//销毁绘制模型
if (MiddleLine != null)
{
MiddleLine.Dissvoe();
MiddleLine = null;
}
if (LeftLine != null)
{
LeftLine.Dissvoe();
LeftLine = null;
}
if (RightLine != null)
{
RightLine.Dissvoe();
RightLine = null;
}
this.IsDrawing = false;
this.IsContinueDraw = false;
IsDeactivate = true;
this.m_checked = false;
if (PointElement != null)
PointElement.Clear();
}
#region 重写BaseCommand
public override void OnCreate(object hook)
{
try
{
if (m_hookHelper == null)
{
//替换Env改动
//m_hookHelper = Env.Instance.KMap.HookHelper;
m_hookHelper = new HookHelperClass();
m_hookHelper.Hook = hook;
}
//初始化编辑对象
if (m_editor == null)
m_editor = new EngineEditorClass();
//m_editor = new EngineEditorClass();
////m_editor.OnStopEditing += m_editor_OnStopEditing;
////m_editor.OnTargetLayerChanged += m_editor_OnTargetLayerChanged;
//snapEnv = (IEngineSnapEnvironment)m_editor;
if (drawParam == null)
{
drawParam = new DrawParam();
drawParam.DrawMode = DrawMode.LeftAndRight;
drawParam.Width = 10;
drawParam.ToloranceScale = 0.2;
drawParam.DLBM = "1003-公路用地";
}
if (density == null)
{
density = new VerificationOfFeatureNodeDensity(m_hookHelper);
}
}
catch (Exception ex)
{
LogAPI.Debug("初始化 画线物面（线状地物面）工具 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("初始化 画线物面（线状地物面）工具 时异常信息结束");
}
}
//void m_editor_OnTargetLayerChanged()
//{
// if (paramFrm != null)
// {
// paramFrm.Close();
// paramFrm = null;
// base.Deactivate();
// }
//}
//void m_editor_OnStopEditing(bool saveChanges)
//{
// if (paramFrm != null)
// {
// paramFrm.Close();
// paramFrm = null;
// base.Deactivate();
// }
//}
private bool IsDeactivate;
private IMapService _MapService;
public override void OnClick()
{
try
{
//KGIS.Framework.Common.Utils.LicenseManager.License();
_MapService = MapsManager.Instance.MapService;
Init();
panTool.OnClick();
base.OnClick();
if (paramFrm != null)
{
paramFrm.Close();
}
if (paramFrm == null)
{
paramFrm = new FrmDrawDoublePolyline(drawParam);
paramFrm.SetParam(true, true);
paramFrm.Closed += paramFrm_Closed;
paramFrm.Title = "画线物面";
paramFrm.Topmost = true;
paramFrm.ShowInTaskbar = false;
paramFrm.Top = 175;
paramFrm.Left = 235;
paramFrm.Show();
}
//timer.Interval = 100;
//timer.Tick += timer_Tick;
//autoDistinguishTimer.Interval = 100;
//autoDistinguishTimer.Tick += autoDistinguishTimer_Tick;
//AllowMoveMap = true;
//Env.Instance.Platfrom.MapMouseWheel -= Platfrom_MapMouseWheel;
//Env.Instance.Platfrom.MapMouseWheel += Platfrom_MapMouseWheel;
//MiddleLine = new LineModel(m_hookHelper.ActiveView, esriSimpleLineStyle.esriSLSDash, 0.5);
//LeftLine = new LineModel(m_hookHelper.ActiveView, esriSimpleLineStyle.esriSLSSolid);
//RightLine = new LineModel(m_hookHelper.ActiveView, esriSimpleLineStyle.esriSLSSolid);
//IsSpaceDown = false; IsDeactivate = false;
//base.m_cursor = System.Windows.Forms.Cursors.Cross;
base.OnClick();
//layer = Common.Utility.LayerHelper.GetLayerByName<KOTilesLayer>(m_hookHelper.FocusMap, "YGYXT");
this.m_checked = true;
}
catch (Exception ex)
{
LogAPI.Debug("初始化 画线物面（线状地物面）工具 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("初始化 画线物面（线状地物面）工具 时异常信息结束");
MessageHelper.ShowError(ex.Message);
}
}
/// <summary>
/// 鼠标距离地图边界一定距离时，开始漫游
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void timer_Tick(object sender, EventArgs e)
{
try
{
IEnvelope extent = this.m_hookHelper.ActiveView.Extent;
int centerX = 0;
int centerY = 0;
int rX = 0;
int rY = 0;
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(new PointClass() { X = extent.XMax, Y = extent.YMin }, out rX, out rY);
IPoint centerPoint = new PointClass() { X = extent.XMin + (extent.XMax - extent.XMin) / 2, Y = extent.YMin + (extent.YMax - extent.YMin) / 2 };
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(centerPoint, out centerX, out centerY);
bool NeedPan = false;
if (!IsDrawing)
{
timer.Stop();
return;
}
if (MousePoint.X < MapBorderDistance)
{
NeedPan = true;
centerX -= 5;
}
if (MousePoint.Y < MapBorderDistance)
{
NeedPan = true;
centerY -= 5;
}
if (Math.Abs(rX - MousePoint.X) < MapBorderDistance)
{
NeedPan = true;
centerX += 5;
}
if (Math.Abs(rY - MousePoint.Y) < MapBorderDistance)
{
NeedPan = true;
centerY += 5;
}
if (NeedPan)
{
centerPoint = m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(centerX, centerY);
(this.m_hookHelper.Hook as IMapControl2).CenterAt(centerPoint);
}
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 鼠标距离地图边界一定距离时，开始漫游 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 鼠标距离地图边界一定距离时，开始漫游 时异常信息结束");
}
}
void paramFrm_Closed(object sender, EventArgs e)
{
if (paramFrm != null)
{
paramFrm.Closed -= paramFrm_Closed;
}
paramFrm = null;
}
public override bool Enabled
{
get
{
if (MapsManager.Instance == null) return false;
object pTemp = (MapsManager.Instance.CurrProjectInfo as ProjectInfo);
if (pTemp == null)
{
return false;
}
else
{
ILayer layer = m_editor.TargetLayer;//Env.Instance.KMap.EngEditor.TargetLayer;
if (m_editor.EditState == esriEngineEditState.esriEngineStateEditing && layer != null && (layer as ESRI.ArcGIS.Carto.IFeatureLayer).FeatureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
return true;
}
else
{
return false;
}
}
}
}
#endregion
IElement element = null;
private int IsEnterClickNum = 0;
private bool IsShiftDown = false;
#region 重写BaseTool
//[LogWrite(Description = "")]
public override void OnKeyDown(int keyCode, int Shift)
{
try
{
//键盘按下时不启用放大缩小功能
//替换Env改动
//Env.Instance.KMap.AxMapControl.AutoMouseWheel = false;
//Env.Instance.KMap.AxMapControl.AutoKeyboardScrolling = false;
(m_hookHelper.Hook as IMapControlDefault).AutoMouseWheel = false;
(m_hookHelper.Hook as IMapControlDefault).AutoKeyboardScrolling = false;
//----------------------
IPoint point = this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(MousePoint.X, MousePoint.Y);//Env.Instance.MousePoint;
//替换Env改动
//Env.Instance.CurrentKeyDown = keyCode;
Platform.Instance.SetCurrentKeyDown(keyCode);
if (keyCode == (int)ConsoleKey.F7)
{
try
{
#region 自动识别
if (TempCenterPoint == null || TempWidht <= 0)
{
//如果没有识别到，调用手动取点
this.OnKeyDown((int)ConsoleKey.F8, Shift);
return;
}
this.IsAuto = true;
if (TempWidht > 0 && MiddleLine.Line.PointCount == 1 && !IsChangedWidht)
{
//如果识别到点，并且已经绘制了一个点，并且宽度没有手动调整过，则应用识别的宽度并修改第一个点的宽度
this.drawParam.Width = TempWidht;
this.OnMouseMove(1, Shift, MousePoint.X, MousePoint.Y);
//Moveing(point);
}
this.drawParam.Width = TempWidht;
///当前线上面最后一个点的X坐标
int endX = -1;
///当前线上面最后一个点的Y坐标
int endY = -1;
///下一个点的X坐标
int nextX = -1;
///下一个点的Y坐标
int nextY = -1;
if (MiddleLine.Line.PointCount > 0)
{
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1), out endX, out endY);
}
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(TempCenterPoint, out nextX, out nextY);
if (nextX != -1 && nextY != -1 && endX != -1 && endY != -1)
{
IPolyline line = new PolylineClass();
line.FromPoint = MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1);
line.ToPoint = TempCenterPoint;
//当两次取点距离小于30像素的时候，取消上一个点，以第二次的点为主
if (line.Length < 3)
{
//取消上一个点
this.OnKeyDown((int)ConsoleKey.F9, 0);
}
///以识别到的点进行绘制新的点
LeftClick(nextX, nextY);
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1), out nextX, out nextY);
//MoveMapExtent(nextX, nextY, 100);
}
TempCenterPoint = null;
#endregion
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 键盘按下 F7 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 键盘按下 F7 时异常信息结束");
}
}
else if (keyCode == (int)ConsoleKey.F8)
{
try
{
#region 快捷键取点
this.IsAuto = false;
///当前线上面最后一个点的X坐标
int endX = -1;
///当前线上面最后一个点的Y坐标
int endY = -1;
if (MiddleLine.Line.PointCount > 0)
{
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1), out endX, out endY);
}
//当两次取点距离小于30像素的时候，取消上一个点，以第二次的点为主
if (endX != -1 && endY != -1 && Math.Abs(MousePoint.X - endX) < 30 && Math.Abs(MousePoint.Y - endY) < 30)
{
//取消上一个点
this.OnKeyDown((int)ConsoleKey.F9, 0);
}
//绘制新的点
this.LeftClick(MousePoint.X, MousePoint.Y);
#endregion
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 键盘按下 F8 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 键盘按下 F8 时异常信息结束");
}
}
else if (keyCode == (int)ConsoleKey.F9 || keyCode == (int)ConsoleKey.Escape)
{
try
{
if (this.MiddleLine.Line.PointCount > 0 && this.IsDrawing == false)
{
//删除点
if (SnapElementPointIndex == -1)
{
SnapElementPointIndex = SnapElement(point, out SnapElementPointLine);
}
if (SnapElementPointIndex != -1 && SnapElementPointLine == 0)
{
MiddleLine.Line.RemovePoints(SnapElementPointIndex, 1);
LeftLine.Line.RemovePoints(SnapElementPointIndex, 1);
RightLine.Line.RemovePoints(SnapElementPointIndex, 1);
MiddleLine.RefreshPoint(SnapElementPointIndex);
LeftLine.RefreshPoint(SnapElementPointIndex);
RightLine.RefreshPoint(SnapElementPointIndex);
SnapElementPointIndex = -1;
SnapElementPointLine = int.MaxValue;
}
}
else
{
#region 撤销点
IPointCollection tempLine = new Polyline();
if (LeftLine.Line.PointCount > 1)
{
LeftLine.Line.RemovePoints(LeftLine.Line.PointCount - 1, 1);
tempLine.AddPoint(LeftLine.Line.get_Point(LeftLine.Line.PointCount - 1));
}
else if (LeftLine.Line.PointCount == 1)
{
LeftLine.Line.RemovePoints(LeftLine.Line.PointCount - 1, 1);
LeftLine.FollowLine.Stop();
//LeftLine.FollowLine.RemovePoints(0, LeftLine.FollowLine.PointCount);
//LeftLine.DrawLine();
}
if (RightLine.Line.PointCount > 1)
{
RightLine.Line.RemovePoints(RightLine.Line.PointCount - 1, 1);
tempLine.AddPoint(RightLine.Line.get_Point(RightLine.Line.PointCount - 1));
}
else if (RightLine.Line.PointCount == 1)
{
RightLine.Line.RemovePoints(RightLine.Line.PointCount - 1, 1);
LeftLine.FollowLine.Stop();
//RightLine.FollowLine.RemovePoints(0, RightLine.FollowLine.PointCount);
//RightLine.DrawLine();
}
if (MiddleLine.Line.PointCount > 1)
{
MiddleLine.Line.RemovePoints(MiddleLine.Line.PointCount - 1, 1);
IEnvelope extent = m_hookHelper.ActiveView.Extent;
IPoint p = MiddleLine.Line.Point[MiddleLine.Line.PointCount - 1];
if (extent.XMax < p.X || extent.XMin > p.X || extent.YMax < p.Y || extent.YMin > p.Y)
{
(this.m_hookHelper.Hook as IMapControl2).CenterAt(p);
}
}
else if (MiddleLine.Line.PointCount == 1)
{
MiddleLine.Line.RemovePoints(MiddleLine.Line.PointCount - 1, 1);
LeftLine.FollowLine.Stop();
//MiddleLine.FollowLine.RemovePoints(0, MiddleLine.FollowLine.PointCount);
//MiddleLine.DrawLine();
PointElement = new List<IElement>();
this.IsDrawing = false;
this.IsContinueDraw = false;
}
//计算前一个点时划线的宽度
//if (tempLine.PointCount == 2)
//{
// this.drawParam.Width = (tempLine as IPolyline).Length;
//}
LeftLine.DrawLine(LeftLine.Line.PointCount);
RightLine.DrawLine(LeftLine.Line.PointCount);
MiddleLine.DrawLine(LeftLine.Line.PointCount);
this.OnMouseMove(1, Shift, MousePoint.X, MousePoint.Y);
//Moveing(point);
#endregion
}
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 键盘按下 F9||ESC 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 键盘按下 F9||ESC 时异常信息结束");
}
}
else if (keyCode == (int)ConsoleKey.Backspace)
{
#region 清除绘制的图形
this.MiddleLine.Reset();
this.LeftLine.Reset();
this.RightLine.Reset();
PointElement = new List<IElement>();
this.IsDrawing = false;
this.IsContinueDraw = false;
#endregion
}
else if (keyCode == (int)ConsoleKey.Spacebar)
{
#region 空格移动地图
if (!IsSpaceDown)
{
base.Deactivate();
IsSpaceDown = true;
}
base.m_cursor = System.Windows.Forms.Cursors.Hand;
//this.OnMouseMove(1, 0, MousePoint.X, MousePoint.Y);
#endregion
}
else if (keyCode == (int)ConsoleKey.D9)
{
#region 减小识别灵敏度
if (this.drawParam.ToloranceScale > 0.05)
{
this.drawParam.ToloranceScale -= 0.05;
autoDistinguishTimer.Stop();
autoDistinguishTimer.Start();
}
else
{
this.drawParam.ToloranceScale = 0.05;
}
#endregion
}
else if (keyCode == (int)ConsoleKey.D0)
{
#region 增加识别灵敏度
if (this.drawParam.ToloranceScale < 0.5)
{
this.drawParam.ToloranceScale += 0.05;
autoDistinguishTimer.Stop();
autoDistinguishTimer.Start();
}
else
{
this.drawParam.ToloranceScale = 0.5;
autoDistinguishTimer.Stop();
autoDistinguishTimer.Start();
}
#endregion
}
else if (keyCode == 17)
{
#region Ctrl键调整双线宽度
if (!IsCtrlDown)
{
//替换Env改动
//Env.Instance.KMap.AxMapControl.AutoMouseWheel = false;
//Env.Instance.KMap.AxMapControl.AutoKeyboardScrolling = false;
(m_hookHelper.Hook as IMapControlDefault).AutoMouseWheel = false;
(m_hookHelper.Hook as IMapControlDefault).AutoKeyboardScrolling = false;
DrawTextElement(point, ref TextElement);
IsCtrlDown = true;
}
#endregion
}
else if (keyCode == 16)
{
this.IsShiftDown = true;
}
else if (keyCode == (int)ConsoleKey.Enter)
{
if (this.MiddleLine.Line.PointCount > 1)
{
if (IsEnterClickNum == 0)
{
IsEnterClickNum++;
IsDrawing = false;
}
else if (IsEnterClickNum == 1)
{
this.DrawComplete();
IsEnterClickNum = 0;
SnapElementPointIndex = -1;
SnapElementPointLine = 0;
IsContinueDraw = false;
}
}
}
else if (keyCode == (int)ConsoleKey.Insert)
{
//增加点
if (SnapElementPointIndex == -1)
{
SnapElementPointIndex = SnapElement(point);
double a = GeometryOperations.getAngle(MiddleLine.Line.get_Point(0), MiddleLine.Line.get_Point(1));
if (SnapElementPointIndex != -1)
{
IPoint p = MiddleLine.Line.get_Point(SnapElementPointIndex);
double angle = GeometryOperations.getAngle(p, point);
if ((a > 0 && angle > 0) || (a < 0 && angle < 0))
{
SnapElementPointIndex++;
}
else
{
//if (a < 0 && angle < 0)
//{
// SnapElementPointIndex++;
//}
//if (a > 45 && a < 135)
//{
// if (angle > 0)
// {
// SnapElementPointIndex++;
// }
//}
}
IPointCollection newPoint = new Polyline();
newPoint.AddPoint(point);
MiddleLine.Line.InsertPointCollection(SnapElementPointIndex, newPoint);
LeftLine.Line.InsertPointCollection(SnapElementPointIndex, newPoint);
RightLine.Line.InsertPointCollection(SnapElementPointIndex, newPoint);
SnapElementPointLine = 0;
}
}
}
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 键盘按下 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 键盘按下 时异常信息结束");
}
}
//[LogWrite(Description = "")]
public override void OnKeyUp(int keyCode, int Shift)
{
//替换Env改动
//Env.Instance.CurrentKeyDown = -1;
Platform.Instance.SetCurrentKeyDown(-1);
base.OnKeyUp(keyCode, Shift);
if (keyCode == (int)ConsoleKey.Spacebar)
{
if (IsSpaceDown && IsDrawing)
{
m_hookHelper.ActiveView.Refresh();
base.OnClick();
IsSpaceDown = false;
base.m_cursor = System.Windows.Forms.Cursors.Cross;
//this.OnMouseMove(1, 0, MousePoint.X, MousePoint.Y);
}
}
if (keyCode == 17)
{
//替换Env改动
//Env.Instance.KMap.AxMapControl.AutoMouseWheel = true;
//Env.Instance.KMap.AxMapControl.AutoKeyboardScrolling = true;
(m_hookHelper.Hook as IMapControlDefault).AutoMouseWheel = true;
(m_hookHelper.Hook as IMapControlDefault).AutoKeyboardScrolling = true;
DelElement(ref TextElement);
IsCtrlDown = false;
}
if (keyCode == 16)
{
this.IsShiftDown = false;
}
}
//[LogWrite(Description = "")]
public override void OnMouseDown(int Button, int Shift, int X, int Y)
{
try
{
IsAuto = false;
if (IsSpaceDown)
{
base.Deactivate();
panTool.OnMouseDown(1, Shift, X, Y);
return;
}
if (Button == 1)
{
//左键按下取点
IPoint point = m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(X, Y);
if (snapEnv != null)
{
snapEnv.SnapPoint(point);
}
if (this.MiddleLine.Line.PointCount > 0 && IsDrawing == false)
{
#region 调整单个点的位置
if (SnapElementPointIndex == -1)
{
SnapElementPointIndex = SnapElement(point, out SnapElementPointLine);
//IsDrawing = true;
}
else
{
if (SnapElementPointLine == 0)
{
this.MiddleLine.Line.UpdatePoint(SnapElementPointIndex, point);
double angle = 0;
if (SnapElementPointIndex == 0)
{
angle = GeometryOperations.getAngle(point, this.MiddleLine.Line.get_Point(SnapElementPointIndex + 1));
}
else
{
angle = GeometryOperations.getAngle(this.MiddleLine.Line.get_Point(SnapElementPointIndex - 1), point);
}
this.LeftLine.Line.UpdatePoint(SnapElementPointIndex, GeometryOperations.GetPoint(point, this.drawParam.Width * 0.5, -angle));
this.RightLine.Line.UpdatePoint(SnapElementPointIndex, GeometryOperations.GetPoint(point, this.drawParam.Width * -0.5, -angle));
this.MiddleLine.RefreshPoint(SnapElementPointIndex);
this.LeftLine.RefreshPoint(SnapElementPointIndex);
this.RightLine.RefreshPoint(SnapElementPointIndex);
}
else if (SnapElementPointLine == 1)
{
this.LeftLine.Line.UpdatePoint(SnapElementPointIndex, point);
this.LeftLine.RefreshPoint(SnapElementPointIndex);
}
else if (SnapElementPointLine == -1)
{
this.RightLine.Line.UpdatePoint(SnapElementPointIndex, point);
this.RightLine.RefreshPoint(SnapElementPointIndex);
}
SnapElementPointIndex = -1;
IsDrawing = false;
}
#endregion
}
else
{
#region 绘制点
#region 根据道路宽度调整相关参数
if (TempWidht < 10)
{
MinPointDistance = 15;
MaxPointDistance = 40;
}
else if (TempWidht > 15)
{
MinPointDistance = 30;
MaxPointDistance = 80;
}
#endregion
if (this.MiddleLine.Line.PointCount > 0)
{
IPoint p = this.MiddleLine.Line.get_Point(this.MiddleLine.Line.PointCount - 1);
if (p.X == point.X && p.Y == point.Y)
{
return;
}
IPolyline line = new PolylineClass();
line.FromPoint = point;
line.ToPoint = p;
if (line.Length < 3)
{
return;
}
}
if (TempWidht == -1)
{
TempWidht = 10;
}
Drawing(point);
if (this.MiddleLine.Line.PointCount > 0)
this.IsDrawing = true;
else
return;
if (this.MiddleLine.Line.PointCount > 1)
{
IPoint p2 = MiddleLine.Line.get_Point(this.MiddleLine.Line.PointCount - 2);
IPoint p1 = MiddleLine.Line.get_Point(this.MiddleLine.Line.PointCount - 1);
double angle = GeometryOperations.getAngle(p2, p1);
//angle = 90 - angle;
IPolyline tempLine = new PolylineClass();
tempLine.FromPoint = p1;
tempLine.ToPoint = p2;
MoveMapExtent(X, Y, (int)Math.Floor(tempLine.Length));
if (this.drawParam.IsAutoTrack)
{
//this.OnMouseDown(2, Shift, MousePoint.X, MousePoint.Y);
}
}
else
{
MoveMapExtent(X, Y, 100);
}
#endregion
}
}
else if (Button == 2)
{
this.OnKeyDown((int)ConsoleKey.F7, Shift);
}
else if (Button == 4)
{
////鼠标滚轮按下
//base.Deactivate();
//panTool.OnMouseDown(Button, Shift, X, Y);
//this.OnKeyDown((int)ConsoleKey.Enter, Shift);
}
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 按下鼠标 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 按下鼠标 时异常信息结束");
}
}
private bool isRunning = false;
public override void OnMouseMove(int Button, int Shift, int X, int Y)
{
if (isRunning)
return;
isRunning = true;
try
{
if (IsSpaceDown)
{
panTool.OnMouseMove(1, Shift, X, Y);
MousePoint.X = X;
MousePoint.Y = Y;
return;
}
var vT10 = m_hookHelper;
var vT12 = m_hookHelper.ActiveView;
var vT13 = m_hookHelper.ActiveView.ScreenDisplay;
var vT14 = m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation;
var vT15 = m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(X, Y);
IPoint point = m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(X, Y);
if (snapEnv != null)
{
this.SnapPoint(m_hookHelper.ActiveView, point, snapEnv);
}
if (this.MiddleLine.Line.PointCount > 0)
{
if (this.IsDrawing)
{
Moveing(point);
if (MousePoint.X == X && MousePoint.Y == Y)
{
return;
}
else
{
MousePoint.X = X;
MousePoint.Y = Y;
}
autoDistinguishTimer.Stop();
autoDistinguishTimer.Dispose();
try
{
autoDistinguishTimer.Start();
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 移动鼠标后 正在绘制 期间 异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 移动鼠标后 正在绘制 期间 异常信息结束");
System.Windows.Forms.Application.DoEvents();
autoDistinguishTimer.Start();
}
System.Windows.Forms.Application.DoEvents();
#region 当鼠标移动到地图边界时，自动移动地图
if (AllowMoveMap)
{
IEnvelope extent = this.m_hookHelper.ActiveView.Extent;
int rX = 0;
int rY = 0;
//替换Env改动
//Env.Instance.KMap.AxMapControl.FromMapPoint(new PointClass() { X = extent.XMax, Y = extent.YMin }, ref rX, ref rY);
(m_hookHelper.Hook as IMapControlDefault).FromMapPoint(new PointClass() { X = extent.XMax, Y = extent.YMin }, ref rX, ref rY);
bool NeedPan = false;
System.Windows.Forms.Application.DoEvents();
if (X < MapBorderDistance)
{
if (!NeedPan)
{
timer.Start();
}
NeedPan = true;
}
if (Y < MapBorderDistance)
{
if (!NeedPan)
{
timer.Start();
}
NeedPan = true;
}
if (Math.Abs(rX - X) < MapBorderDistance)
{
if (!NeedPan)
{
timer.Start();
}
NeedPan = true;
}
if (Math.Abs(rY - Y) < MapBorderDistance)
{
if (!NeedPan)
{
timer.Start();
}
NeedPan = true;
}
if (!NeedPan)
{
timer.Stop();
NeedPan = false;
}
}
#endregion
}
else
{
MousePoint.X = X;
MousePoint.Y = Y;
if (SnapElementPointIndex != -1)
{
if (SnapElementPointLine == 0)
{
this.MiddleLine.Line.UpdatePoint(SnapElementPointIndex, point);
double angle = 0;
if (SnapElementPointIndex == 0)
{
angle = GeometryOperations.getAngle(point, this.MiddleLine.Line.get_Point(SnapElementPointIndex + 1));
}
else
{
angle = GeometryOperations.getAngle(this.MiddleLine.Line.get_Point(SnapElementPointIndex - 1), point);
}
this.LeftLine.Line.UpdatePoint(SnapElementPointIndex, GeometryOperations.GetPoint(point, this.drawParam.Width * 0.5, -angle));
this.RightLine.Line.UpdatePoint(SnapElementPointIndex, GeometryOperations.GetPoint(point, this.drawParam.Width * -0.5, -angle));
this.MiddleLine.RefreshPoint(SnapElementPointIndex);
this.LeftLine.RefreshPoint(SnapElementPointIndex);
this.RightLine.RefreshPoint(SnapElementPointIndex);
}
else if (SnapElementPointLine == 1)
{
this.LeftLine.Line.UpdatePoint(SnapElementPointIndex, point);
this.LeftLine.RefreshPoint(SnapElementPointIndex);
}
else if (SnapElementPointLine == -1)
{
this.RightLine.Line.UpdatePoint(SnapElementPointIndex, point);
this.RightLine.RefreshPoint(SnapElementPointIndex);
}
autoDistinguishTimer.Stop();
autoDistinguishTimer.Dispose();
try
{
autoDistinguishTimer.Start();
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 移动鼠标后 未在绘制 期间 异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 移动鼠标后 未在绘制 期间 异常信息结束");
System.Windows.Forms.Application.DoEvents();
autoDistinguishTimer.Start();
}
}
}
}
else if (Button == 4)
{
//鼠标滚轮按下
//panTool.OnMouseMove(Button, Shift, X, Y);
//MousePoint.X = X;
//MousePoint.Y = Y;
}
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 移动鼠标后 异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 移动鼠标后 期间 异常信息结束");
}
finally
{
isRunning = false;
}
}
//[LogWrite(Description = "")]
public override void OnMouseUp(int Button, int Shift, int X, int Y)
{
if (Button == 4)
{
//panTool.OnMouseUp(1, Shift, X, Y);
//m_hookHelper.ActiveView.Refresh();
//base.OnClick();
}
else
{
//base.OnMouseUp(button, shift, x, y);
//点击右键时，弹出编辑菜单
if (IsSpaceDown)
{
panTool.OnMouseUp(Button, Shift, X, Y);
}
else
{
base.OnMouseUp(Button, Shift, X, Y);//调用基类的OnMouseDown事件
}
}
}
IPoint m_SnapPoint = null;
bool m_isHasSnap;
//[LogWrite(Description = "")]
public void SnapPoint(IActiveView activeView, IPoint inPoint, IEngineSnapEnvironment m_editEnvironment)
{
if (this.m_isHasSnap && (this.m_SnapPoint != null))
{
this.DrawSnapPoint(activeView, this.m_SnapPoint);
}
this.m_isHasSnap = ((IEngineSnapEnvironment)m_editEnvironment).SnapPoint(inPoint);
if (this.m_isHasSnap)
{
this.m_SnapPoint = inPoint;
this.DrawSnapPoint(activeView, this.m_SnapPoint);
}
}
//[LogWrite(Description = "")]
private void DrawSnapPoint(IActiveView activeView, IPoint point)
{
IScreenDisplay screenDisplay = activeView.ScreenDisplay;
screenDisplay.StartDrawing(screenDisplay.hDC, -1);
IEngineEditProperties engProperties = new EngineEditorClass();
screenDisplay.SetSymbol((ISymbol)engProperties.SnapSymbol);
screenDisplay.DrawPoint(point);
screenDisplay.FinishDrawing();
screenDisplay = null;
}
//CheckAssistant dataCheckView = null;
IPolyline StartLine = null;
IPolyline EndLine = null;
//[LogWrite(Description = "")]
public void DrawComplete()
{
try
{
//if (!ss())
//{
// return;
//}
bool isSplit;
int splitIndex, segIndex;
if (LeftLine.Line.PointCount < 2 || this.RightLine.Line.PointCount < 2)
{
return;
}
IFeatureLayer layer = m_editor.TargetLayer as IFeatureLayer;
if (layer == null || layer.FeatureClass == null)
{
return;
}
int selectIdZYQ = 1;
IUcZYQMagrHelper ucZYQMagrHelper = null;
ProjectInfo ProInfo = MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo;
if (ProInfo != null && ProInfo.ProjType == EnumProjType.BHTBTQ && Platform.Instance.SystemType == SystemTypeEnum.BGFWCG)
{
ucZYQMagrHelper = BundleRuntime.Instance.GetFirstOrDefaultService<IUcZYQMagrHelper>();
if (ucZYQMagrHelper != null)
{
selectIdZYQ = ucZYQMagrHelper.GetCheckedID();
}
}
m_editor.StartOperation();
//if (StartLine == null)
//{
// StartLine = new PolylineClass();
// StartLine.FromPoint = LeftLine.Line.get_Point(0);
// StartLine.ToPoint = RightLine.Line.get_Point(0);
//}
//if (EndLine == null)
//{
// EndLine = new PolylineClass();
// EndLine.FromPoint = LeftLine.Line.get_Point(LeftLine.Line.PointCount - 1);
// EndLine.ToPoint = RightLine.Line.get_Point(LeftLine.Line.PointCount - 1);
//}
IPointCollection line1 = new Polyline();
line1.AddPoint((LeftLine.Line as IPolyline).FromPoint);
line1.AddPoint((RightLine.Line as IPolyline).FromPoint);
IGeometry geo1 = line1 as IGeometry;
IPointCollection line2 = new Polyline();
line2.AddPoint((LeftLine.Line as IPolyline).ToPoint);
line2.AddPoint((RightLine.Line as IPolyline).ToPoint);
IGeometry geo4 = line2 as IGeometry;
//IGeometry geo1 = StartLine;
IGeometry geo2 = LeftLine.Line as IGeometry;
IGeometry geo3 = RightLine.Line as IGeometry;
//IGeometry geo4 = EndLine;
ITopologicalOperator2 topo = geo1 as ITopologicalOperator2;
topo.Simplify();
ITopologicalOperator topo1 = geo2 as ITopologicalOperator;
topo1.Simplify();
topo = topo.Union(geo2) as ITopologicalOperator2;
topo.Simplify();
topo1 = geo3 as ITopologicalOperator;
topo1.Simplify();
topo = topo.Union(geo3) as ITopologicalOperator2;
topo1 = geo4 as ITopologicalOperator;
topo1.Simplify();
IPointCollection allPoint = topo.Union(geo4) as IPointCollection;
IFeatureSelection featureSelection = layer as IFeatureSelection;
featureSelection.Clear();
IPointCollection polygon = new PolygonClass();
polygon.AddPointCollection(allPoint);
IGeometry geo = (polygon as IGeometry);
geo.SpatialReference = m_hookHelper.FocusMap.SpatialReference;
//验证区域授权
//if (RegionAuthorize == null)
//{
// RegionAuthorize = new RegionAuthorize();
//}
//if (!RegionAuthorize.ValidateAuthorize(LeftLine.Line as IGeometry) || !RegionAuthorize.ValidateAuthorize(RightLine.Line as IGeometry))
//{
// MessageHelper.ShowError("绘制图形不在授权区域范围内！");
// return;
//}
if (density == null)
{
density = new VerificationOfFeatureNodeDensity(m_hookHelper);
}
geo = density.Verification(geo);
//白明雅 2020-04-01
//if (dataCheckService != null)
//{
// dataCheckService.GeometryCheck(geo, layer);
//}
DrawFeature(layer.FeatureClass, geo, featureSelection);
if (ucZYQMagrHelper != null)
{
ucZYQMagrHelper.AddMask(selectIdZYQ);
}
#region
//IFeatureLayer selectFeatureLayer = _MapService.GetFeatureLayerByName(Env.Instance.DefaultValue.ED_DLTB_TableName);
////if (selectFeatureLayer == null || selectFeatureLayer.FeatureClass == null)
////{
//// selectFeatureLayer = Env.Instance.KMap.GetFeatureLayerByName(this.m_hookHelper.ActiveView.FocusMap, Env.Instance.DefaultValue.DLTB_TableName) as IFeatureLayer;
////}
////按权属分割、合并图斑
//List<IGeometry> GeoList = null;
//if (selectFeatureLayer != null && selectFeatureLayer.FeatureClass != null)
//{
// GeoList = FeatureAPI.GenerateNewFeature(geo, selectFeatureLayer.FeatureClass);
//}
////else
////{
//// DrawFeature(layer.FeatureClass, geo, featureSelection);
////}
//if (GeoList == null || GeoList.Count <= 0)
//{
// GeoList = new List<IGeometry>() { geo };
// //DrawFeature(layer.FeatureClass, geo, featureSelection);
//}
//IIdentify identify = layer as IIdentify;
//List<IFeature> featureList = new List<IFeature>();
//for (int k = 0; k < GeoList.Count; k++)
//{
// IGeometry item = GeoList[k];
// if (item.IsEmpty)
// continue;
// ITopologicalOperator2 topologicalOperator2 = item as ITopologicalOperator2;
// IPolyline pPolyline = topologicalOperator2.Boundary as IPolyline;
// item.SpatialReference = this.m_hookHelper.FocusMap.SpatialReference;
// if (identify == null)
// {
// continue;
// }
// IArray iarray = identify.Identify(item);
// if (iarray == null)
// {
// continue;
// }
// for (int i = 0; i < iarray.Count; i++)
// {
// IFeatureIdentifyObj pFeatIdObj = iarray.get_Element(i) as IFeatureIdentifyObj;
// IRowIdentifyObject pRowObj = pFeatIdObj as IRowIdentifyObject;
// IFeature newFeature = pRowObj.Row as IFeature;
// newFeature.Shape.SpatialReference = this.m_hookHelper.FocusMap.SpatialReference;
// ITopologicalOperator topOper = newFeature.ShapeCopy as ITopologicalOperator;
// IGeometry geometryNew = topOper.Difference(item);
// if (geometryNew != null && !geometryNew.IsEmpty)
// {
// newFeature.Shape = geometryNew;
// }
// //属性继承
// //FeatureHelper.SetFeatureAttribute(newFeature);//以后待改回
// //if (!string.IsNullOrWhiteSpace(this.drawParam.DLBM))
// //{
// // string[] str = this.drawParam.DLBM.Split(new string[] { "-" }, StringSplitOptions.RemoveEmptyEntries);
// // if (str.Length == 2)
// // {
// // int index = newFeature.Fields.FindField("DLBM");
// // if (index > -1)
// // {
// // newFeature.set_Value(index, str[0]);
// // }
// // index = newFeature.Fields.FindField("DLMC");
// // if (index > -1)
// // {
// // newFeature.set_Value(index, str[1]);
// // }
// // }
// //}
// newFeature.Store();
// KGIS.Framework.AE.FeatureAPI.SplitMultipartFeature(new List<IFeature>() { newFeature });
// IPointCollection pointCollection = geometryNew as IPointCollection;
// for (int j = 0; j < pointCollection.PointCount; j++)
// {
// if (KGIS.Framework.AE.FeatureAPI.IsInterSect(pointCollection.get_Point(j) as IGeometry, item))
// {
// pPolyline.SplitAtPoint(pointCollection.get_Point(j), false, false, out isSplit, out splitIndex, out segIndex);
// }
// }
// GeoList[k] = KGIS.Framework.AE.FeatureAPI.ConstructPolygonFromPolyline(pPolyline);
// }
//}
//featureSelection.Clear();
//foreach (IGeometry item in GeoList)
//{
// DrawFeature(layer.FeatureClass, item, featureSelection);
//}
//featureSelection.SelectionChanged();
#endregion
#region 打开数据检查助手
//if (dataCheckView == null)
//{
// dataCheckView = new CheckAssistant(m_hookHelper);
// dataCheckView.Width = 310;
// IPoint topRightPoint = new PointClass();
// topRightPoint.X = m_hookHelper.ActiveView.Extent.XMax;
// topRightPoint.Y = m_hookHelper.ActiveView.Extent.YMax;
// topRightPoint.SpatialReference = m_hookHelper.FocusMap.SpatialReference;
// int x2 = 0;
// int y2 = 0;
// //获取地图工作区右下角的坐标x2,y2，用于判断当前鼠标点是否在右边/下边边界处
// this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(topRightPoint, out x2, out y2);
// System.Drawing.Point screenPoint = Env.Instance.KMap.AxMapControl.PointToScreen(new System.Drawing.Point(x2, y2));
// dataCheckView.Top = screenPoint.Y;
// dataCheckView.Left = screenPoint.X - 310;
// dataCheckView.Closed += dataCheckView_Closed;
// dataCheckView.ShowInMainForm();
//}
//dataCheckView.InitData(featureList);
#endregion
m_editor.StopOperation("画线物面");
//KGIS.Common.Utility.CustomLogAPI.WriteSystemOperationLog("数据新增", "画线物面");
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 执行 DrawComplete 异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 执行 DrawComplete 异常信息结束");
m_editor.AbortOperation();
MessageHelper.ShowError(ex.Message);
}
finally
{
DelElement(ref element);
PointElement = new List<IElement>();
this.LeftLine.Dissvoe();
this.RightLine.Dissvoe();
this.MiddleLine.Dissvoe();
this.MiddleLine.Init();
this.RightLine.Init();
this.LeftLine.Init();
this.m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewBackground, null, m_hookHelper.ActiveView.Extent);
this.m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, m_hookHelper.ActiveView.Extent);
this.TempWidht = -1;
this.TempCenterPoint = null;
this.IsChangedWidht = false;
this.IsDrawing = false;
this.IsContinueDraw = false;
}
}
/// <summary>
/// 绘制图形到图层上
/// </summary>
/// <param name="pFeatureClass"></param>
/// <param name="geometry"></param>
/// <param name="featureSelection"></param>
//[LogWrite(Description = "")]
private void DrawFeature(IFeatureClass pFeatureClass, IGeometry geometry, IFeatureSelection featureSelection)
{
//绘制出空图形问题
if (geometry == null || geometry.IsEmpty)
{
return;
}
IFeature feature = pFeatureClass.CreateFeature();
feature.Shape = geometry;
feature.Shape.SpatialReference = m_hookHelper.FocusMap.SpatialReference;
//属性继承
//FeatureHelper.SetFeatureAttribute(feature);//以后待改回
if (!string.IsNullOrWhiteSpace(this.drawParam.DLBM))
{
string[] str = this.drawParam.DLBM.Split(new string[] { "-" }, StringSplitOptions.RemoveEmptyEntries);
if (str.Length == 2)
{
int index = feature.Fields.FindField("DLBM");
if (index > -1)
{
feature.set_Value(index, str[0]);
}
index = feature.Fields.FindField("DLMC");
if (index > -1)
{
feature.set_Value(index, str[1]);
}
}
}
feature.Store();
featureSelection.Add(feature);
}
//[LogWrite(Description = "")]
void dataCheckView_Closed(object sender, EventArgs e)
{
//dataCheckView = null;
}
//[LogWrite(Description = "")]
public override bool Deactivate()
{
int selectIdZYQ = 1;
IUcZYQMagrHelper ucZYQMagrHelper = null;
ProjectInfo ProInfo = MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo;
if (ProInfo != null && ProInfo.ProjType == EnumProjType.BHTBTQ && Platform.Instance.SystemType == SystemTypeEnum.BGFWCG)
{
ucZYQMagrHelper = BundleRuntime.Instance.GetFirstOrDefaultService<IUcZYQMagrHelper>();
if (ucZYQMagrHelper != null)
{
selectIdZYQ = ucZYQMagrHelper.GetCheckedID();
}
}
Dispose();
if (paramFrm != null)
{
paramFrm.Close();
paramFrm = null;
}
if (ucZYQMagrHelper != null)
{
ucZYQMagrHelper.AddMask(selectIdZYQ);
}
//if (this.MiddleLine != null)
//{
// this.MiddleLine.Dissvoe();
//}
//if (this.LeftLine != null)
//{
// this.LeftLine.Dissvoe();
//}
//if (this.RightLine != null)
//{
// this.RightLine.Dissvoe();
//}
//this.MiddleLine = new LineModel(m_hookHelper.ActiveView, esriSimpleLineStyle.esriSLSDash, 0.5);
//this.LeftLine = new LineModel(m_hookHelper.ActiveView, esriSimpleLineStyle.esriSLSSolid);
//this.RightLine = new LineModel(m_hookHelper.ActiveView, esriSimpleLineStyle.esriSLSSolid);
//Env.Instance.Platfrom.MapMouseWheel -= Platfrom_MapMouseWheel;
//if (timer != null)
//{
// timer.Tick -= timer_Tick;
// timer.Stop();
//}
//autoDistinguishTimer.Tick -= autoDistinguishTimer_Tick;
//autoDistinguishTimer.Stop();
//PointElement = new List<IElement>();
//this.IsDrawing = false;
//IsDeactivate = true;
//this.m_checked = false;
return base.Deactivate();
}
//[LogWrite(Description = "")]
private void LeftClick(int X, int Y)
{
//左键按下取点
IPoint point = m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(X, Y);
if (this.MiddleLine.Line.PointCount > 0 && IsDrawing == false)
{
#region 调整单个点的位置
if (SnapElementPointIndex == -1)
{
SnapElementPointIndex = SnapElement(point, out SnapElementPointLine);
//IsDrawing = true;
}
else
{
if (SnapElementPointLine == 0)
{
this.MiddleLine.Line.UpdatePoint(SnapElementPointIndex, point);
double angle = 0;
if (SnapElementPointIndex == 0)
{
angle = GeometryOperations.getAngle(point, this.MiddleLine.Line.get_Point(SnapElementPointIndex + 1));
}
else
{
angle = GeometryOperations.getAngle(this.MiddleLine.Line.get_Point(SnapElementPointIndex - 1), point);
}
this.LeftLine.Line.UpdatePoint(SnapElementPointIndex, GeometryOperations.GetPoint(point, this.drawParam.Width * 0.5, -angle));
this.RightLine.Line.UpdatePoint(SnapElementPointIndex, GeometryOperations.GetPoint(point, this.drawParam.Width * -0.5, -angle));
this.MiddleLine.RefreshPoint(SnapElementPointIndex);
this.LeftLine.RefreshPoint(SnapElementPointIndex);
this.RightLine.RefreshPoint(SnapElementPointIndex);
}
else if (SnapElementPointLine == 1)
{
this.LeftLine.Line.UpdatePoint(SnapElementPointIndex, point);
this.LeftLine.RefreshPoint(SnapElementPointIndex);
}
else if (SnapElementPointLine == -1)
{
this.RightLine.Line.UpdatePoint(SnapElementPointIndex, point);
this.RightLine.RefreshPoint(SnapElementPointIndex);
}
SnapElementPointIndex = -1;
IsDrawing = false;
}
#endregion
}
else
{
#region 绘制点
#region 根据道路宽度调整相关参数
if (TempWidht < 10)
{
MinPointDistance = 15;
MaxPointDistance = 40;
}
else if (TempWidht > 15)
{
MinPointDistance = 30;
MaxPointDistance = 80;
}
#endregion
if (this.MiddleLine.Line.PointCount > 0)
{
IPoint p = this.MiddleLine.Line.get_Point(this.MiddleLine.Line.PointCount - 1);
if (p.X == point.X && p.Y == point.Y)
{
return;
}
IPolyline line = new PolylineClass();
line.FromPoint = point;
line.ToPoint = p;
if (line.Length < 3)
{
return;
}
}
if (TempWidht == -1)
{
TempWidht = 10;
}
Drawing(point);
if (this.MiddleLine.Line.PointCount > 0)
this.IsDrawing = true;
if (this.MiddleLine.Line.PointCount > 1)
{
IPoint p2 = MiddleLine.Line.get_Point(this.MiddleLine.Line.PointCount - 2);
IPoint p1 = MiddleLine.Line.get_Point(this.MiddleLine.Line.PointCount - 1);
double angle = GeometryOperations.getAngle(p2, p1);
//angle = 90 - angle;
IPolyline tempLine = new PolylineClass();
tempLine.FromPoint = p1;
tempLine.ToPoint = p2;
MoveMapExtent(X, Y, (int)Math.Floor(tempLine.Length));
if (this.drawParam.IsAutoTrack)
{
//this.OnMouseDown(2, Shift, MousePoint.X, MousePoint.Y);
}
}
else
{
MoveMapExtent(X, Y, 100);
}
#endregion
}
}
#endregion
/// <summary>
/// 获取两条线段交点
/// </summary>
/// <param name="pointStart"></param>
/// <param name="pointEnd"></param>
/// <param name="targetGeo"></param>
/// <returns></returns>
//[LogWrite(Description = "")]
private IPoint GetIntersectPoint(IPoint pointStart, IPoint pointEnd, IGeometry targetGeo)
{
IPolyline newLine = new PolylineClass();
IPointCollection newLinepoint = newLine as IPointCollection;
if (pointStart.X == pointEnd.X)
{
double minY = targetGeo.Envelope.YMin;
newLinepoint.AddPoint(pointStart);
newLinepoint.AddPoint(new PointClass() { X = pointEnd.X, Y = minY });
}
else
{
double pointX = pointEnd.X > pointStart.X ? targetGeo.Envelope.XMax : targetGeo.Envelope.XMin;
double sourceLineK = (pointStart.Y - pointEnd.Y) / (pointStart.X - pointEnd.X);
double longPointY = pointStart.Y - ((pointStart.X - pointX) * sourceLineK);
newLinepoint.AddPoint(pointStart);
newLinepoint.AddPoint(new PointClass() { X = pointX, Y = longPointY });
}
ITopologicalOperator topOper = targetGeo as ITopologicalOperator;
IGeometry geometry = topOper.Intersect(newLine as IGeometry, esriGeometryDimension.esriGeometry0Dimension);
return GetMinDisPoint(geometry, pointEnd);
}
//[LogWrite(Description = "")]
private IPoint GetMinDisPoint(IGeometry geometry, IPoint pointEnd)
{
if (!geometry.IsEmpty)
{
IProximityOperator operatorPr = geometry as IProximityOperator;
return operatorPr.ReturnNearestPoint(pointEnd, esriSegmentExtension.esriExtendTangents);
}
return null;
}
/// <summary>
/// 滚动滚轮调整宽度
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
//[LogWrite(Description = "")]
void Platfrom_MapMouseWheel(object sender, System.Windows.Forms.MouseEventArgs e)
{
if (IsDeactivate)
return;
if (drawParam != null)
{
//替换Env改动
//if (Env.Instance.CurrentKeyDown == 17)
if (Platform.Instance.GetCurrentKeyDown() == 17)
{
IPoint point = this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(MousePoint.X, MousePoint.Y);
if (e.Delta > 0)
{
drawParam.Width = drawParam.Width + 0.5;
}
else if (e.Delta < 0 && drawParam.Width > 0)
{
drawParam.Width = drawParam.Width - 0.5;
}
int d = (int)Math.Abs(drawParam.Width);
if (d == 0)
return;
if (d < 10)
{
drawParam.ToloranceScale = 0.1;
}
if (d == 10)
{
drawParam.ToloranceScale = 0.15;
}
if (d > 10 && d < 20)
{
drawParam.ToloranceScale = 0.2;
}
if (d == 20)
{
drawParam.ToloranceScale = 0.25;
}
if (d > 20)
{
drawParam.ToloranceScale = 0.3;
}
if (d > 30)
{
drawParam.ToloranceScale = 0.4;
}
if (d > 40)
{
drawParam.ToloranceScale = 0.5;
}
this.IsChangedWidht = true;
DrawTextElement(point, ref TextElement);
//this.OnMouseMove(1, 0, MousePoint.X, MousePoint.Y);
//传入IsChangedWidht
Moveing(point, IsChangedWidht);
}
else
{
//shift+滚轮调节识别度
//if (IsDrawing)
if (IsShiftDown)
{
if (e.Delta > 0)
{
//drawParam.ToloranceScale += 0.05;
this.OnKeyDown((int)ConsoleKey.D0, 0);
}
if (e.Delta < 0)
{
//drawParam.ToloranceScale -= 0.05;
this.OnKeyDown((int)ConsoleKey.D9, 0);
}
this.OnKeyDown((int)ConsoleKey.P, 0);
}
else
{
//添加滚轮放大缩小地图
//替换Env改动
//Env.Instance.KMap.AxMapControl.AutoMouseWheel = true;
//Env.Instance.KMap.AxMapControl.AutoKeyboardScrolling = true;
(m_hookHelper.Hook as IMapControlDefault).AutoMouseWheel = true;
(m_hookHelper.Hook as IMapControlDefault).AutoKeyboardScrolling = true;
//----------------
}
}
}
}
/// <summary>
/// 移动地图范围
/// </summary>
/// <param name="X">鼠标位置的X坐标</param>
/// <param name="Y">鼠标位置的Y坐标</param>
/// <param name="pWidth">鼠标位置距离地图边界的宽度</param>
//[LogWrite(Description = "")]
private void MoveMapExtent(int X, int Y, int pWidth)
{
//鼠标点击的点
IPoint point = m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(X, Y);
#region 当鼠标点击屏幕边界时移动地图范围
//当前屏幕中心点坐标
IPoint centerPoint = new PointClass() { X = (this.m_hookHelper.ActiveView.Extent.XMax - this.m_hookHelper.ActiveView.Extent.Width / 2), Y = (this.m_hookHelper.ActiveView.Extent.YMax - this.m_hookHelper.ActiveView.Extent.Height / 2) };
//地图窗口右下角坐标
IPoint p = new PointClass() { X = this.m_hookHelper.ActiveView.Extent.XMax, Y = this.m_hookHelper.ActiveView.Extent.YMin };
//鼠标点击到边界时移动地图
int x2 = 0;
int y2 = 0;
//获取地图工作区右下角的坐标x2,y2，用于判断当前鼠标点是否在右边/下边边界处
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(p, out x2, out y2);
//获取工作区右下角的坐标对应的屏幕坐标
//替换Env改动
//System.Drawing.Point rightBottomPoint = Env.Instance.KMap.AxMapControl.PointToScreen(new System.Drawing.Point(x2, y2));
System.Drawing.Point rightBottomPoint = _MapService.PointToScreen(new System.Drawing.Point(x2, y2));
//获取工作区左上角的坐标对应的屏幕坐标
//替换Env改动
//System.Drawing.Point leftTopPoint = Env.Instance.KMap.AxMapControl.PointToScreen(new System.Drawing.Point(0, 0));
System.Drawing.Point leftTopPoint = _MapService.PointToScreen(new System.Drawing.Point(0, 0));
IPoint CPoint = point;
double angle = 0;
if (MiddleLine.Line.PointCount > 1)
{
//计算当前道路线的方向
angle = GeometryOperations.getAngle(MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 2), MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1));
}
//计算屏幕每像素代表实际横向距离
double d1 = this.m_hookHelper.ActiveView.Extent.Width / x2;
//计算屏幕每像素代表实际纵向距离
double d2 = this.m_hookHelper.ActiveView.Extent.Height / y2;
IPoint p1 = MiddleLine.Line.get_Point(this.MiddleLine.Line.PointCount - 1);
//自动识别的下一个点的位置
IPoint n_p = null;
//第一次识别的点
IPoint n_p2 = null;
//第二次识别的点
IPoint n_p3 = null;
//记录自动识别下一点的宽度
IPolyline line = null;
//第一次识别的宽度
IPolyline line2 = null;
//第二次识别的宽度
IPolyline line3 = null;
IPolyline tempLine = new PolylineClass();
if (this.MiddleLine.Line.PointCount > 1)
{
double d = 0;
if (this.MiddleLine.Line.PointCount > 0)
{
tempLine.FromPoint = this.LeftLine.Line.get_Point(this.LeftLine.Line.PointCount - 1);
tempLine.ToPoint = this.RightLine.Line.get_Point(this.RightLine.Line.PointCount - 1);
d = tempLine.Length;
}
n_p2 = GeometryOperations.GetPoint(p1, pWidth, 90 - angle);
line2 = (IPolyline)AutoDistinguish3(0, n_p2);
if (Math.Abs(line2.Length - d) > 4)
{
n_p3 = GeometryOperations.GetPoint(p1, pWidth + pWidth * 0.1, 90 - angle);
line3 = (IPolyline)AutoDistinguish3(0, n_p3);
if (Math.Abs(line2.Length - d) < Math.Abs(line3.Length - d))
{
n_p = n_p2;
line = line2;
}
else
{
n_p = n_p3;
line = line3;
}
}
else
{
n_p = n_p2;
line = line2;
}
#region 将自动识别的点显示在地图上
TempCenterPoint = new PointClass();
TempCenterPoint.X = line.FromPoint.X - (line.FromPoint.X - line.ToPoint.X) / 2;
TempCenterPoint.Y = line.FromPoint.Y - (line.FromPoint.Y - line.ToPoint.Y) / 2;
TempCenterPoint.SpatialReference = (line as IPolyline).SpatialReference;
IPointCollection newPoints = new Polyline();
newPoints.AddPoint(line.FromPoint);
newPoints.AddPoint(TempCenterPoint);
newPoints.AddPoint(line.ToPoint);
DrawPoint(newPoints);
#endregion
}
if (n_p != null)
{
//计算下一个点的坐标对应的地图工作区坐标位置
int nextX = 0;
int nextY = 0;
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(n_p, out nextX, out nextY);
if (nextX - 50 < 0 || nextX + 50 > x2)
{
#region 横向移动
double moveWidth = 0;
if (nextX - 50 < 0)
{
moveWidth = Math.Abs(nextX - 50) * d1;
}
else if (nextX + 50 > x2)
{
moveWidth = (nextX + 50 - x2) * d1;
}
if (moveWidth < this.m_hookHelper.ActiveView.Extent.Width / 2)
{
moveWidth = this.m_hookHelper.ActiveView.Extent.Width * 0.5;
}
if (angle != 0)
{
CPoint = GeometryOperations.GetPoint(centerPoint, moveWidth, 90 - angle);
(this.m_hookHelper.Hook as IMapControl2).CenterAt(CPoint);
}
else
{
(this.m_hookHelper.Hook as IMapControl2).CenterAt(CPoint);
this.OnMouseMove(1, 0, MousePoint.X + 1, MousePoint.Y + 1);
}
#endregion
}
if (nextY < 50 || nextY + 50 > y2)
{
#region 纵向移动
double moveWidth = 0;
if (nextY + 50 < 0)
{
moveWidth = Math.Abs(nextY - 50) * d2;
if (moveWidth < this.m_hookHelper.ActiveView.Extent.Height / 2)
{
moveWidth = this.m_hookHelper.ActiveView.Extent.Height * 0.5;
}
}
else if (nextY + 50 > y2)
{
moveWidth = (nextY + 50 - y2) * d2;
if (moveWidth < this.m_hookHelper.ActiveView.Extent.Height / 2)
{
moveWidth = this.m_hookHelper.ActiveView.Extent.Height * 0.5;
}
}
if (angle != 0)
{
CPoint = GeometryOperations.GetPoint(centerPoint, moveWidth, 90 - angle);
(this.m_hookHelper.Hook as IMapControl2).CenterAt(CPoint);
}
else
{
(this.m_hookHelper.Hook as IMapControl2).CenterAt(CPoint);
this.OnMouseMove(1, 0, MousePoint.X + 1, MousePoint.Y + 1);
}
#endregion
}
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(TempCenterPoint, out nextX, out nextY);
int m_x = 0;
int m_y = 0;
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(n_p, out m_x, out m_y);
//替换Env改动
//System.Drawing.Point screenPoint = Env.Instance.KMap.AxMapControl.PointToScreen(new System.Drawing.Point(m_x, m_y));
System.Drawing.Point screenPoint = _MapService.PointToScreen(new System.Drawing.Point(m_x, m_y));
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(p1, out nextX, out nextY);
this.MousePoint.X = m_x;
this.MousePoint.Y = m_y;
//SetCursorPos(screenPoint.X, screenPoint.Y);
if (this.drawParam.IsAutoStep)
{
SetCursorPos(screenPoint.X, screenPoint.Y);
}
//this.m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography,null,
if (this.drawParam.IsAutoTrack && IsAuto)
{
double angle2 = GeometryOperations.getAngle(MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1), TempCenterPoint);
ITopologicalOperator topo = TempCenterPoint as ITopologicalOperator;
IGeometry geo = topo.Buffer(line.Length / 2);
ImgDistinguish imgDis = new ImgDistinguish();
TilesImage img = imgDis.GetImg(geo.Envelope);
if (img == null)
return;
img.PixelCount = 9;
int gray1 = img.GetGrayValue(TempCenterPoint);
topo = MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1) as ITopologicalOperator;
geo = topo.Buffer(line.Length / 2);
img = imgDis.GetImg(geo.Envelope);
if (img == null)
return;
img.PixelCount = 9;
int gray2 = img.GetGrayValue(MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1));
int w = pWidth / 3;
if (Math.Abs(Math.Abs(angle) - Math.Abs(angle2)) < 10)
{
if (Math.Abs(gray1 - gray2) < 25 && Math.Abs(line.Length - tempLine.Length) < tempLine.Length * 0.3)
{
IsAutoTrackPoint = true;
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(TempCenterPoint, out nextX, out nextY);
this.OnMouseDown(2, 0, nextX, nextY);
}
else
{
int i = 0;
while (pWidth - w >= 3)
{
i++;
w = w + pWidth / 3;
if (i > 3)
{
IsAutoTrackPoint = false;
break;
}
IPoint c_P = AutoTrack(X, Y, pWidth - w);
if (c_P != null)
{
TempCenterPoint = c_P;
IsAutoTrackPoint = true;
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(TempCenterPoint, out nextX, out nextY);
this.OnMouseDown(2, 0, nextX, nextY);
break;
}
else
{
IsAutoTrackPoint = false;
}
}
}
}
else
{
if (Math.Abs(gray1 - gray2) < 30 && Math.Abs(line.Length - tempLine.Length) < tempLine.Length * 0.3)
{
IsAutoTrackPoint = true;
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(TempCenterPoint, out nextX, out nextY);
this.OnMouseDown(2, 0, nextX, nextY);
}
else
{
int i = 0;
while (pWidth - w >= 3)
{
i++;
w = w + pWidth / 3;
if (i > 3)
{
IsAutoTrackPoint = false;
break;
}
IPoint c_P = AutoTrack(X, Y, pWidth - w);
if (c_P != null)
{
TempCenterPoint = c_P;
IsAutoTrackPoint = true;
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(TempCenterPoint, out nextX, out nextY);
this.OnMouseDown(2, 0, nextX, nextY);
break;
}
else
{
IsAutoTrackPoint = false;
}
}
//if (pWidth / 3 >= 3)
//{
// MoveMapExtent(X, Y, pWidth / 3);
//}
//else
//{
// IsAutoTrackPoint = false;
//}
}
}
}
}
#endregion
}
//[LogWrite(Description = "")]
private IPoint AutoTrack(int X, int Y, int pWidth)
{
IPoint result = null;
try
{
//鼠标点击的点
IPoint point = m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(X, Y);
#region 当鼠标点击屏幕边界时移动地图范围
//当前屏幕中心点坐标
IPoint centerPoint = new PointClass() { X = (this.m_hookHelper.ActiveView.Extent.XMax - this.m_hookHelper.ActiveView.Extent.Width / 2), Y = (this.m_hookHelper.ActiveView.Extent.YMax - this.m_hookHelper.ActiveView.Extent.Height / 2) };
//地图窗口右下角坐标
IPoint p = new PointClass() { X = this.m_hookHelper.ActiveView.Extent.XMax, Y = this.m_hookHelper.ActiveView.Extent.YMin };
//鼠标点击到边界时移动地图
int x2 = 0;
int y2 = 0;
//获取地图工作区右下角的坐标x2,y2，用于判断当前鼠标点是否在右边/下边边界处
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(p, out x2, out y2);
//获取工作区右下角的坐标对应的屏幕坐标
//替换Env改动
//System.Drawing.Point rightBottomPoint = Env.Instance.KMap.AxMapControl.PointToScreen(new System.Drawing.Point(x2, y2));
System.Drawing.Point rightBottomPoint = _MapService.PointToScreen(new System.Drawing.Point(x2, y2));
//获取工作区左上角的坐标对应的屏幕坐标
//替换Env改动
//System.Drawing.Point leftTopPoint = Env.Instance.KMap.AxMapControl.PointToScreen(new System.Drawing.Point(0, 0));
System.Drawing.Point leftTopPoint = _MapService.PointToScreen(new System.Drawing.Point(0, 0));
IPoint CPoint = point;
double angle = 0;
if (MiddleLine.Line.PointCount > 1)
{
//计算当前道路线的方向
angle = GeometryOperations.getAngle(MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 2), MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1));
}
//计算屏幕每像素代表实际横向距离
double d1 = this.m_hookHelper.ActiveView.Extent.Width / x2;
//计算屏幕每像素代表实际纵向距离
double d2 = this.m_hookHelper.ActiveView.Extent.Height / y2;
IPoint p1 = MiddleLine.Line.get_Point(this.MiddleLine.Line.PointCount - 1);
//自动识别的下一个点的位置
IPoint n_p = null;
//第一次识别的点
IPoint n_p2 = null;
//第二次识别的点
IPoint n_p3 = null;
//记录自动识别下一点的宽度
IPolyline line = null;
//第一次识别的宽度
IPolyline line2 = null;
//第二次识别的宽度
IPolyline line3 = null;
IPolyline tempLine = new PolylineClass();
if (this.MiddleLine.Line.PointCount > 1)
{
double d = 0;
if (this.MiddleLine.Line.PointCount > 0)
{
tempLine.FromPoint = this.LeftLine.Line.get_Point(this.LeftLine.Line.PointCount - 1);
tempLine.ToPoint = this.RightLine.Line.get_Point(this.RightLine.Line.PointCount - 1);
d = tempLine.Length;
}
n_p2 = GeometryOperations.GetPoint(p1, pWidth, 90 - angle);
line2 = (IPolyline)AutoDistinguish3(0, n_p2);
if (Math.Abs(line2.Length - d) > 4)
{
n_p3 = GeometryOperations.GetPoint(p1, pWidth + pWidth * 0.1, 90 - angle);
line3 = (IPolyline)AutoDistinguish3(0, n_p3);
if (Math.Abs(line2.Length - d) < Math.Abs(line3.Length - d))
{
n_p = n_p2;
line = line2;
}
else
{
n_p = n_p3;
line = line3;
}
}
else
{
n_p = n_p2;
line = line2;
}
#region 将自动识别的点显示在地图上
TempCenterPoint = new PointClass();
TempCenterPoint.X = line.FromPoint.X - (line.FromPoint.X - line.ToPoint.X) / 2;
TempCenterPoint.Y = line.FromPoint.Y - (line.FromPoint.Y - line.ToPoint.Y) / 2;
TempCenterPoint.SpatialReference = (line as IPolyline).SpatialReference;
IPointCollection newPoints = new Polyline();
newPoints.AddPoint(line.FromPoint);
newPoints.AddPoint(TempCenterPoint);
newPoints.AddPoint(line.ToPoint);
DrawPoint(newPoints);
#endregion
}
//计算下一个点的坐标对应的地图工作区坐标位置
int nextX = 0;
int nextY = 0;
#region
//this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(n_p, out nextX, out nextY);
//if (nextX - 50 < 0 || nextX + 50 > x2)
//{
// #region 横向移动
// double moveWidth = 0;
// if (nextX - 50 < 0)
// {
// moveWidth = Math.Abs(nextX - 50) * d1;
// }
// else if (nextX + 50 > x2)
// {
// moveWidth = (nextX + 50 - x2) * d1;
// }
// if (angle != 0)
// {
// CPoint = GeometryOperations.GetPoint(centerPoint, moveWidth, 90 - angle);
// (this.m_hookHelper.Hook as IMapControl2).CenterAt(CPoint);
// }
// else
// {
// (this.m_hookHelper.Hook as IMapControl2).CenterAt(CPoint);
// this.OnMouseMove(1, 0, MousePoint.X + 1, MousePoint.Y + 1);
// }
// #endregion
//}
//if (nextY + 50 < 0 || nextY + 50 > y2)
//{
// #region 纵向移动
// double moveWidth = 0;
// if (nextY + 50 < 0)
// {
// moveWidth = Math.Abs(nextY - 50) * d2;
// }
// else if (nextY + 50 > y2)
// {
// moveWidth = -(nextY + 50 - x2) * d2;
// }
// if (angle != 0)
// {
// CPoint = GeometryOperations.GetPoint(centerPoint, moveWidth, 90 - angle);
// (this.m_hookHelper.Hook as IMapControl2).CenterAt(CPoint);
// }
// else
// {
// (this.m_hookHelper.Hook as IMapControl2).CenterAt(CPoint);
// this.OnMouseMove(1, 0, MousePoint.X + 1, MousePoint.Y + 1);
// }
// #endregion
//}
#endregion
if (n_p != null)
{
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(TempCenterPoint, out nextX, out nextY);
int m_x = 0;
int m_y = 0;
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(n_p, out m_x, out m_y);
//替换Env改动
//System.Drawing.Point screenPoint = Env.Instance.KMap.AxMapControl.PointToScreen(new System.Drawing.Point(m_x, m_y));
System.Drawing.Point screenPoint = _MapService.PointToScreen(new System.Drawing.Point(m_x, m_y));
this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(p1, out nextX, out nextY);
this.MousePoint.X = m_x;
this.MousePoint.Y = m_y;
SetCursorPos(screenPoint.X, screenPoint.Y);
if (this.drawParam.IsAutoTrack)
{
double angle2 = GeometryOperations.getAngle(MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1), TempCenterPoint);
ITopologicalOperator topo = TempCenterPoint as ITopologicalOperator;
IGeometry geo = topo.Buffer(line.Length / 2);
ImgDistinguish imgDis = new ImgDistinguish();
TilesImage img = imgDis.GetImg(geo.Envelope);
if (img == null)
return result;
img.PixelCount = 9;
int gray1 = img.GetGrayValue(TempCenterPoint);
topo = MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1) as ITopologicalOperator;
geo = topo.Buffer(line.Length / 2);
img = imgDis.GetImg(geo.Envelope);
if (img == null)
return result;
img.PixelCount = 9;
int gray2 = img.GetGrayValue(MiddleLine.Line.get_Point(MiddleLine.Line.PointCount - 1));
if (Math.Abs(Math.Abs(angle) - Math.Abs(angle2)) < 5 && Math.Abs(gray1 - gray2) < 25 && Math.Abs(line.Length - tempLine.Length) < tempLine.Length * 0.3)
{
//IsAutoTrackPoint = true;
//this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.FromMapPoint(TempCenterPoint, out nextX, out nextY);
//this.OnMouseDown(2, 0, nextX, nextY);
result = TempCenterPoint;
}
else
{
//IsAutoTrackPoint = false;
}
}
}
return result;
#endregion
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 执行 AutoTrack 异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 执行 AutoTrack 异常信息结束");
throw ex;
}
}
/// <summary>
/// 定时进行自动识别影像
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
//[LogWrite(Description = "")]
void autoDistinguishTimer_Tick(object sender, EventArgs e)
{
try
{
IPoint point = this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(MousePoint.X, MousePoint.Y);
double angle = 0;
if (MiddleLine.Line.PointCount <= 0)
{
return;
#region
//IPolyline p1 = (IPolyline)AutoDistinguish(0);
//IPolyline p2 = (IPolyline)AutoDistinguish(90);
//if (p1.Length > p2.Length)
//{
// TempWidht = p2.Length;
// #region 将自动识别记过显示在地图上
// TempCenterPoint = new PointClass();
// TempCenterPoint.X = p2.FromPoint.X - (p2.FromPoint.X - p2.ToPoint.X) / 2;
// TempCenterPoint.Y = p2.FromPoint.Y - (p2.FromPoint.Y - p2.ToPoint.Y) / 2;
// TempCenterPoint.SpatialReference = (p2 as IPolyline).SpatialReference;
// IPointCollection newPoints = new Polyline();
// newPoints.AddPoint(p2.FromPoint);
// newPoints.AddPoint(TempCenterPoint);
// newPoints.AddPoint(p2.ToPoint);
// DrawPoint(newPoints);
// #endregion
//}
//else
//{
// TempWidht = p1.Length;
// #region 将自动识别记过显示在地图上
// TempCenterPoint = new PointClass();
// TempCenterPoint.X = p1.FromPoint.X - (p1.FromPoint.X - p1.ToPoint.X) / 2;
// TempCenterPoint.Y = p1.FromPoint.Y - (p1.FromPoint.Y - p1.ToPoint.Y) / 2;
// TempCenterPoint.SpatialReference = (p1 as IPolyline).SpatialReference;
// IPointCollection newPoints = new Polyline();
// newPoints.AddPoint(p1.FromPoint);
// newPoints.AddPoint(TempCenterPoint);
// newPoints.AddPoint(p1.ToPoint);
// DrawPoint(newPoints);
// #endregion
//}
#endregion
}
else
{
//LogAPI.Debug("开始时间：" + DateTime.Now.Subtract();
angle = GeometryOperations.getAngle(MiddleLine.Line.Point[MiddleLine.Line.PointCount - 1], point);
if (double.IsNaN(angle) && (MiddleLine.Line.PointCount - 2) > -1)
{
angle = GeometryOperations.getAngle(MiddleLine.Line.Point[MiddleLine.Line.PointCount - 2], point);
}
if (!Double.IsNaN(angle))
{
//DateTime t1 = DateTime.Now;
//Int32 d = t1.Minute * 60 * 1000 + t1.Second * 1000 + t1.Millisecond;
//LogAPI.Debug("开始时间：" + (t1.Minute * 60 * 1000 + t1.Second * 1000 + t1.Millisecond));
IPolyline polyline = (IPolyline)AutoDistinguish(angle);
this.drawParam.ToloranceScale += 0.05;
IPolyline polyline1 = (IPolyline)AutoDistinguish(angle);
this.drawParam.ToloranceScale -= 0.1;
IPolyline polyline2 = (IPolyline)AutoDistinguish(angle);
this.drawParam.ToloranceScale += 0.05;
double d = this.drawParam.Width;
if (this.MiddleLine.Line.PointCount > 0)
{
IPolyline tempLine = new PolylineClass();
tempLine.FromPoint = this.LeftLine.Line.get_Point(this.LeftLine.Line.PointCount - 1);
tempLine.ToPoint = this.RightLine.Line.get_Point(this.RightLine.Line.PointCount - 1);
d = tempLine.Length;
}
if (Math.Abs(polyline.Length - d) < Math.Abs(polyline1.Length - d))
{
if (Math.Abs(polyline.Length - d) > Math.Abs(polyline2.Length - d))
{
polyline = polyline2;
}
}
else
{
if (Math.Abs(polyline1.Length - d) > Math.Abs(polyline2.Length - d))
{
polyline = polyline2;
}
else
{
polyline = polyline1;
}
}
TempWidht = polyline.Length;
if ((TempWidht > this.drawParam.Width + this.drawParam.Width * 0.5 || TempWidht < this.drawParam.Width - this.drawParam.Width * 0.5) && this.MiddleLine.Line.PointCount > 1)
{
TempWidht = -1;
TempCenterPoint = null;
try
{
if (PointElement.Count > 0)
{
foreach (IElement item in PointElement)
{
m_hookHelper.ActiveView.GraphicsContainer.DeleteElement(item);
}
PointElement = new List<IElement>();
m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, m_hookHelper.ActiveView.Extent);
}
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程 中 定时进行自动识别影像 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程 中 定时进行自动识别影像 异常信息结束");
}
}
else
{
#region 将自动识别的点显示在地图上
TempCenterPoint = new PointClass();
TempCenterPoint.X = polyline.FromPoint.X - (polyline.FromPoint.X - polyline.ToPoint.X) / 2;
TempCenterPoint.Y = polyline.FromPoint.Y - (polyline.FromPoint.Y - polyline.ToPoint.Y) / 2;
TempCenterPoint.SpatialReference = (polyline as IPolyline).SpatialReference;
IPointCollection newPoints = new Polyline();
newPoints.AddPoint(polyline.FromPoint);
newPoints.AddPoint(TempCenterPoint);
newPoints.AddPoint(polyline.ToPoint);
DrawPoint(newPoints);
#endregion
}
//DateTime t2 = DateTime.Now;
//Int32 d2 = t2.Minute * 60 * 1000 + t2.Second * 1000 + t2.Millisecond;
//LogAPI.Debug("识别结束:" + (t2.Minute * 60 * 1000 + t2.Second * 1000 + t2.Millisecond));
//LogAPI.Debug("识别结束:" + (d2 - d) + "毫秒");
}
}
autoDistinguishTimer.Stop();
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 定时进行自动识别影像 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 定时进行自动识别影像 时异常信息结束");
}
}
#region 捕捉
//[LogWrite(Description = "")]
private List<IFeature> Snapping(IPoint pPoint, List<IFeatureLayer> pLayers)
{
List<IFeature> result = new List<IFeature>();
try
{
if (pPoint != null && pLayers != null)
{
foreach (IFeatureLayer item in pLayers)
{
IIdentify identify = item as IIdentify;
if (identify == null)
continue;
ESRI.ArcGIS.esriSystem.IArray array = identify.Identify(pPoint);
if (array == null)
continue;
for (int i = 0; i < array.Count; i++)
{
IRowIdentifyObject row = (IRowIdentifyObject)array.get_Element(i);
if (row == null)
continue;
IFeature f = row.Row as IFeature;
result.Add(f);
}
}
}
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 捕捉 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 捕捉 时异常信息结束");
}
return result;
}
#endregion
#region 获取所有可见图层
/// <summary>
/// 获取当前地图中可见的矢量图层
/// </summary>
/// <param name="pMap"></param>
/// <returns></returns>
//[LogWrite(Description = "")]
private List<IFeatureLayer> GetVisibleLayer(IMap pMap, esriGeometryType geoType = esriGeometryType.esriGeometryAny)
{
List<IFeatureLayer> result = new List<IFeatureLayer>();
if (pMap == null)
return result;
try
{
for (int i = 0; i < pMap.LayerCount; i++)
{
ILayer layer = pMap.get_Layer(i);
if (layer is IFeatureLayer)
{
if ((layer as IFeatureLayer).Visible && (layer as IFeatureLayer).FeatureClass.ShapeType == geoType)
{
result.Add(layer as IFeatureLayer);
}
}
else if (layer is ICompositeLayer)
{
if ((layer as IGroupLayer).Visible)
{
result.AddRange(GetVisibleLayerByGroupLayer(layer as ICompositeLayer, geoType));
}
}
}
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 获取当前地图中可见的矢量图层 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 获取当前地图中可见的矢量图层 时异常信息结束");
}
return result;
}
//[LogWrite(Description = "")]
private List<IFeatureLayer> GetVisibleLayerByGroupLayer(ICompositeLayer pGroupLayer, esriGeometryType geoType = esriGeometryType.esriGeometryAny)
{
List<IFeatureLayer> result = new List<IFeatureLayer>();
if (pGroupLayer != null && pGroupLayer.Count > 0)
{
for (int i = 0; i < pGroupLayer.Count; i++)
{
ILayer layer = pGroupLayer.get_Layer(i);
if (layer is IAnnotationLayer)
{
}
else if (layer is IGroupLayer)
{
if ((layer as IGroupLayer).Visible)
{
result.AddRange(GetVisibleLayerByGroupLayer(layer as ICompositeLayer, geoType));
}
}
else
{
if (layer is IFeatureLayer)
{
if ((layer as IFeatureLayer).Visible && (layer as IFeatureLayer).FeatureClass.ShapeType == geoType)
{
result.Add((IFeatureLayer)layer);
}
}
}
}
}
return result;
}
#endregion
#region 绘制相关私有函数
//[LogWrite(Description = "")]
private IPointCollection AutoDistinguish3(double angle = 0, IPoint pPoint = null)
{
IPolyline polyline = (IPolyline)AutoDistinguish(angle, pPoint);
this.drawParam.ToloranceScale += 0.05;
IPolyline polyline1 = (IPolyline)AutoDistinguish(angle, pPoint);
this.drawParam.ToloranceScale -= 0.1;
IPolyline polyline2 = (IPolyline)AutoDistinguish(angle, pPoint);
this.drawParam.ToloranceScale += 0.05;
double d = this.drawParam.Width;
if (this.MiddleLine.Line.PointCount > 0)
{
IPolyline tempLine = new PolylineClass();
tempLine.FromPoint = this.LeftLine.Line.get_Point(this.LeftLine.Line.PointCount - 1);
tempLine.ToPoint = this.RightLine.Line.get_Point(this.RightLine.Line.PointCount - 1);
d = tempLine.Length;
}
if (Math.Abs(polyline.Length - d) < Math.Abs(polyline1.Length - d))
{
if (Math.Abs(polyline.Length - d) > Math.Abs(polyline2.Length - d))
{
polyline = polyline2;
}
}
else
{
if (Math.Abs(polyline1.Length - d) > Math.Abs(polyline2.Length - d))
{
polyline = polyline2;
}
else
{
polyline = polyline1;
}
}
return polyline as IPointCollection;
}
/// <summary>
/// 自动识别中心点
/// </summary>
//[LogWrite(Description = "")]
private IPointCollection AutoDistinguish(double angle = 0, IPoint pPoint = null)
{
#region 自动识别道路中心线
IPoint point = pPoint;
if (point == null)
{
point = this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(MousePoint.X, MousePoint.Y);
}
IPointCollection vertical = new Polyline();
vertical.AddPoint(point);
vertical.AddPoint(point);
//KOTilesLayer layer = Common.Utility.LayerHelper.GetLayerByName<KOTilesLayer>(m_hookHelper.FocusMap, "YGYXT");
double InitWidht = 50;
//获取鼠标点周围50米的范围
IEnvelope env = new EnvelopeClass();
//计算当前道路的角度
if (MiddleLine.Line.PointCount > 1)
{
env.XMax = point.X + this.drawParam.Width;
env.XMin = point.X - this.drawParam.Width;
env.YMax = point.Y + this.drawParam.Width;
env.YMin = point.Y - this.drawParam.Width;
InitWidht = drawParam.Width;
angle = GeometryOperations.getAngle(MiddleLine.Line.Point[MiddleLine.Line.PointCount - 1], point);
if (double.IsNaN(angle) && (MiddleLine.Line.PointCount - 2) > -1)
{
angle = GeometryOperations.getAngle(MiddleLine.Line.Point[MiddleLine.Line.PointCount - 2], point);
}
if (Double.IsNaN(angle))
return vertical;
}
else
{
env.XMax = point.X + InitWidht / 2;
env.XMin = point.X - InitWidht / 2;
env.YMax = point.Y + InitWidht / 2;
env.YMin = point.Y - InitWidht / 2;
}
env.SpatialReference = m_hookHelper.FocusMap.SpatialReference;
if (double.IsNaN(angle))
return vertical;
//根据范围获取影像图片
ImgDistinguish imgDis = new ImgDistinguish();
TilesImage img = imgDis.GetImg(env);
if (img == null)
return vertical;
img.PixelCount = 49;
//获取平均灰度值
int Gray = img.GetGrayValue(point);
//重新设置单次搜索像素个数
img.PixelCount = 1;
//计算单次搜索的实际距离
double distance = img.Resolution * Math.Sqrt(img.PixelCount);
//记录已经搜索的总距离
double sumDistance = distance;
//检索出在容差范围内的平均灰度值集合
List<int> grayValues = new List<int>();
grayValues.Add(Gray);
//记录参考点左边的错误像素个数
int leftBadPixelCount = 0;
//记录参考点右边的错误像素个数
int rightBadPixelCount = 0;
//记录容差范围内的灰度平均值
double tolerance = 0;
///容差比例
double toloranceScale = this.drawParam.ToloranceScale;
//容差半径（污点宽度）
double toloranceRadius = 2.5;
while (sumDistance < InitWidht)
{
#region 循环对比像素值
tolerance = Math.Floor((double)grayValues.Sum() / grayValues.Count);
if (leftBadPixelCount < toloranceRadius / distance)
{
IPoint leftPoint = GeometryOperations.GetPoint(point, sumDistance, -angle);
int grayvalue = img.GetGrayValue(leftPoint);
if (grayvalue == -1)
break;
if (Math.Abs(grayvalue - tolerance) < tolerance * toloranceScale)
{
leftBadPixelCount = 0;
grayValues.Add(grayvalue);
vertical.UpdatePoint(0, leftPoint);
}
else
{
leftBadPixelCount++;
if (leftBadPixelCount < toloranceRadius / distance / 5)
{
vertical.UpdatePoint(0, leftPoint);
}
}
}
if (rightBadPixelCount < toloranceRadius / distance)
{
IPoint rightPoint = GeometryOperations.GetPoint(point, -sumDistance, -angle);
int grayvalue = img.GetGrayValue(rightPoint);
if (grayvalue == -1)
break;
if (Math.Abs(grayvalue - tolerance) < tolerance * toloranceScale)
{
rightBadPixelCount = 0;
grayValues.Add(grayvalue);
vertical.UpdatePoint(1, rightPoint);
}
else
{
rightBadPixelCount++;
if (rightBadPixelCount < toloranceRadius / distance / 5)
{
vertical.UpdatePoint(1, rightPoint);
}
}
}
sumDistance += distance;
#endregion
}
return vertical;
#endregion
}
/// <summary>
/// 自动识别中心点
/// </summary>
//[LogWrite(Description = "")]
private IPointCollection AutoDistinguish2(IPoint pPoint, double angle, double pWidht)
{
#region 自动识别道路中心线
IPoint point = pPoint;
IPointCollection vertical = new Polyline();
vertical.AddPoint(point);
vertical.AddPoint(point);
//获取鼠标点周围50米的范围
IEnvelope env = new EnvelopeClass();
env.XMax = point.X + pWidht;
env.XMin = point.X - pWidht;
env.YMax = point.Y + pWidht;
env.YMin = point.Y - pWidht;
env.SpatialReference = m_hookHelper.FocusMap.SpatialReference;
if (double.IsNaN(angle))
return vertical;
//根据范围获取影像图片
ImgDistinguish imgDis = new ImgDistinguish();
TilesImage img = imgDis.GetImg(env);
if (img == null)
return vertical;
img.PixelCount = 49;
//获取平均灰度值
int Gray = img.GetGrayValue(point);
//重新设置单次搜索像素个数
img.PixelCount = 1;
//计算单次搜索的实际距离
double distance = img.Resolution * Math.Sqrt(img.PixelCount);
//记录已经搜索的总距离
double sumDistance = distance;
//检索出在容差范围内的平均灰度值集合
List<int> grayValues = new List<int>();
grayValues.Add(Gray);
//记录参考点左边的错误像素个数
int leftBadPixelCount = 0;
//记录参考点右边的错误像素个数
int rightBadPixelCount = 0;
//记录容差范围内的灰度平均值
double tolerance = 0;
///容差比例
double toloranceScale = this.drawParam.ToloranceScale;
//容差半径
double toloranceRadius = 2.5;
while (sumDistance < pWidht)
{
#region 循环对比像素值
tolerance = Math.Floor((double)grayValues.Sum() / grayValues.Count);
if (leftBadPixelCount < toloranceRadius / distance)
{
IPoint leftPoint = GeometryOperations.GetPoint(point, sumDistance, -angle);
int grayvalue = img.GetGrayValue(leftPoint);
if (grayvalue == -1)
break;
if (Math.Abs(grayvalue - tolerance) < tolerance * toloranceScale)
{
leftBadPixelCount = 0;
grayValues.Add(grayvalue);
vertical.UpdatePoint(0, leftPoint);
}
else
{
leftBadPixelCount++;
if (leftBadPixelCount < toloranceRadius / distance / 5)
{
vertical.UpdatePoint(0, leftPoint);
}
}
}
if (rightBadPixelCount < toloranceRadius / distance)
{
IPoint rightPoint = GeometryOperations.GetPoint(point, -sumDistance, -angle);
int grayvalue = img.GetGrayValue(rightPoint);
if (grayvalue == -1)
break;
if (Math.Abs(grayvalue - tolerance) < tolerance * toloranceScale)
{
rightBadPixelCount = 0;
grayValues.Add(grayvalue);
vertical.UpdatePoint(1, rightPoint);
}
else
{
rightBadPixelCount++;
if (rightBadPixelCount < toloranceRadius / distance / 5)
{
vertical.UpdatePoint(1, rightPoint);
}
}
}
sumDistance += distance;
#endregion
}
return vertical;
#endregion
}
/// <summary>
/// 绘制
/// </summary>
/// <param name="pPoint"></param>
//[LogWrite(Description = "")]
private void Drawing(IPoint pPoint)
{
try
{
if (!IsShiftDown || this.MiddleLine.Line.PointCount > 0)
{
switch (drawParam.DrawMode)
{
case DrawMode.Left:
this.MiddleLine.Scale = -0.5;
this.RightLine.Scale = -1;
DrawPointExe(pPoint, this.LeftLine, this.MiddleLine, this.RightLine);
break;
case DrawMode.Right:
this.LeftLine.Scale = 1;
this.MiddleLine.Scale = 0.5;
DrawPointExe(pPoint, this.RightLine, this.MiddleLine, this.LeftLine);
break;
case DrawMode.LeftAndRight:
this.RightLine.Scale = -0.5;
this.LeftLine.Scale = 0.5;
DrawPointExe(pPoint, this.MiddleLine, this.LeftLine, this.RightLine);
break;
default:
break;
}
}
else
{
IsContinueDraw = true;
IFeatureLayer pFeatureLayer = m_editor.TargetLayer as IFeatureLayer;
IIdentify pIdentify = pFeatureLayer as IIdentify;
IGeometry pGeometry = m_SnapPoint as IGeometry;
//获取鼠标点击的要素
IArray pArray = pIdentify.Identify(pGeometry);
if (pArray == null || pArray.Count <= 0)
{
return;
}
IFeatureIdentifyObj pFeatIdObj = pArray.get_Element(0) as IFeatureIdentifyObj;
IRowIdentifyObject pRowObj = pFeatIdObj as IRowIdentifyObject;
IFeature pFeature = pRowObj.Row as IFeature;
if (pFeature == null)
{
return;
}
IPoint clickedPt = m_SnapPoint;
double searchRadius = 3;
IHitTest hitShape = pFeature.ShapeCopy as IHitTest;
IPoint hitPoint = new PointClass();
double hitDistance = 0;
int hitPartIndex = 0;
int hitSegmentIndex = 0;
bool bRightSide = false;
esriGeometryHitPartType hitPartType = esriGeometryHitPartType.esriGeometryPartBoundary;
//获取鼠标点击的边的索引
hitShape.HitTest(clickedPt, searchRadius, hitPartType, hitPoint, ref hitDistance, ref hitPartIndex, ref hitSegmentIndex, ref bRightSide);
ISegmentCollection segmentCollection = pFeature.ShapeCopy as ISegmentCollection;
//获取点击的边
if (hitSegmentIndex < 0)
{
return;
}
ISegment segment = segmentCollection.get_Segment(hitSegmentIndex);
//将点击边的端点和宽度作为新绘制线物面的起始点和宽度
ContinueDrawLeftPoint = segment.FromPoint;
ContinueDrawRightPoint = segment.ToPoint;
ContinueDrawLength = segment.Length;
drawParam.Width = segment.Length;
IPoint segmentMiddlePoint = new PointClass();
segment.QueryPoint(esriSegmentExtension.esriNoExtension, segment.Length / 2, false, segmentMiddlePoint);
MiddleLine.Line.AddPoint(segmentMiddlePoint);
LeftLine.Line.AddPoint(ContinueDrawLeftPoint);
RightLine.Line.AddPoint(ContinueDrawRightPoint);
}
this.LeftLine.DrawLine();
this.MiddleLine.DrawLine();
this.RightLine.DrawLine();
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 绘制 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 绘制 时异常信息结束");
}
}
/// <summary>
/// 移动
/// </summary>
/// <param name="pPoint"></param>
/// <param name="IsAdjustWidth">添加 宽度调整标识</param>
//[LogWrite(Description = "")]
private void Moveing(IPoint pPoint, bool IsAdjustWidth = false)
{
try
{
switch (drawParam.DrawMode)
{
case DrawMode.Left:
this.MiddleLine.Scale = -0.5;
this.RightLine.Scale = -1;
MovePointExe(pPoint, LeftLine, RightLine, MiddleLine, IsAdjustWidth);
break;
case DrawMode.Right:
this.LeftLine.Scale = 1;
this.MiddleLine.Scale = 0.5;
MovePointExe(pPoint, RightLine, LeftLine, MiddleLine, IsAdjustWidth);
break;
case DrawMode.LeftAndRight:
this.RightLine.Scale = -0.5;
this.LeftLine.Scale = 0.5;
MovePointExe(pPoint, MiddleLine, LeftLine, RightLine, IsAdjustWidth);
break;
default:
break;
}
LeftLine.DrawLine();
RightLine.DrawLine();
MiddleLine.DrawLine();
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 移动 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 移动 时异常信息结束");
}
}
/// <summary>
/// 绘制新的点
/// </summary>
/// <param name="pPoint">点对象</param>
/// <param name="pMainLine">鼠标绘制的线对象</param>
/// <param name="pExtLine1">通过角度和距离计算出来的线对象1</param>
/// <param name="pExtLine2">通过角度和距离计算出来的线对象2</param>
//[LogWrite(Description = "")]
private void DrawPointExe(IPoint pPoint, LineModel pMainLine, LineModel pExtLine1, LineModel pExtLine2, double pAngle = -1)
{
try
{
pMainLine.Line.AddPoint(pPoint);
if (pMainLine.Line.PointCount > 1 && pAngle == -1)
{
pAngle = GeometryOperations.getAngle(pMainLine.Line.get_Point(pMainLine.Line.PointCount - 2), pMainLine.Line.get_Point(pMainLine.Line.PointCount - 1));
}
if (pAngle == -1)
pAngle = 0;
IPoint p1 = GeometryOperations.GetPoint(pPoint, drawParam.Width * pExtLine1.Scale, -pAngle);
if (p1 == null || p1.IsEmpty)
return;
IPoint p2 = GeometryOperations.GetPoint(pPoint, drawParam.Width * pExtLine2.Scale, -pAngle);
if (p2 == null || p2.IsEmpty)
return;
if (pMainLine.Line.PointCount <= 1)
{
pExtLine1.Line.AddPoint(p1);
pExtLine2.Line.AddPoint(p2);
return;
}
//判断第一个点是否识别到已有要素边界
if (pMainLine.Line.PointCount == 2)
{
#region 起始端线
IPolyline line = null;
IPolyline leftLine = GeneratePolyline(pExtLine1.Line.get_Point(0));
if (leftLine != null && !leftLine.IsEmpty)
{ line = leftLine; }
IPolyline rightLine = GeneratePolyline(pExtLine2.Line.get_Point(0));
IPolyline mainLine = GeneratePolyline(pMainLine.Line.get_Point(0));
if (rightLine != null && !rightLine.IsEmpty)
{
if (line != null)
{
ITopologicalOperator topo = line as ITopologicalOperator;
line = topo.Union(rightLine) as IPolyline;
}
else
{
line = rightLine;
}
}
if (mainLine != null && !mainLine.IsEmpty)
{
if (line != null)
{
ITopologicalOperator topo = line as ITopologicalOperator;
line = topo.Union(mainLine) as IPolyline;
}
else
{
line = mainLine;
}
}
if (line != null && !line.IsEmpty)
{
StartLine = GetSubCurve(line, pExtLine1.Line.get_Point(0), pExtLine2.Line.get_Point(0));
}
#endregion
}
#region 结束端线
//优化效率，GeneratePolyline方法比较耗时
if (IsShiftDown)
{
IPolyline endLine = null;
IPolyline tempLine = GeneratePolyline(pMainLine.Line.get_Point(pMainLine.Line.PointCount - 1));
if (tempLine != null && !tempLine.IsEmpty)
{
endLine = tempLine;
IPoint p4 = GetIntersectPoint(pExtLine1.Line.get_Point(pExtLine1.Line.PointCount - 1), p1, tempLine as IPolyline);
if (p4 != null && !p4.IsEmpty)
p1 = p4;
IPoint p3 = GetIntersectPoint(pExtLine2.Line.get_Point(pExtLine2.Line.PointCount - 1), p2, tempLine as IPolyline);
if (p3 != null && !p3.IsEmpty)
p2 = p3;
EndLine = GetSubCurve(endLine, p1, p2);
}
}
pExtLine1.Line.AddPoint(p1);
pExtLine2.Line.AddPoint(p2);
if (EndLine != null && IsShiftDown)
{
this.DrawComplete();
}
#endregion
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 绘制新的点 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 绘制新的点 时异常信息结束");
}
}
/// <summary>
/// 移动现有的点
/// </summary>
/// <param name="pPoint">目标点</param>
/// <param name="pMainLine">鼠标绘制的线对象</param>
/// <param name="pExtLine1">通过角度和距离计算出来的线对象1</param>
/// <param name="pExtLine2">通过角度和距离计算出来的线对象2</param>
/// <param name="IsAdjustWidth">添加 宽度调整标识</param>
//[LogWrite(Description = "")]
private void MovePointExe(IPoint pPoint, LineModel pMainLine, LineModel pExtLine1, LineModel pExtLine2, bool IsAdjustWidth = false)
{
try
{
if (pMainLine.Line.PointCount < 1 || pExtLine1.Line.PointCount < 1 || pExtLine1.Line.PointCount < 1)
return;
double angle = GeometryOperations.getAngle(pMainLine.Line.Point[pMainLine.Line.PointCount - 1], pPoint);
if (Double.IsNaN(angle))
return;
IPoint pExtLine1StartPoint = null;
IPoint pExtLine2StartPoint = null;
IPoint pExtLine1EndPoint = null;
IPoint pExtLine2EndPoint = null;
//获取鼠标跟随线上的第二个点
pExtLine1EndPoint = GeometryOperations.GetPoint(pPoint, drawParam.Width * pExtLine1.Scale, -angle);
pExtLine2EndPoint = GeometryOperations.GetPoint(pPoint, drawParam.Width * pExtLine2.Scale, -angle);
if (pMainLine.Line.PointCount == 1)
{
pExtLine1StartPoint = GeometryOperations.GetPoint(pMainLine.Line.get_Point(0), drawParam.Width * pExtLine1.Scale, -angle);
pExtLine2StartPoint = GeometryOperations.GetPoint(pMainLine.Line.get_Point(0), drawParam.Width * pExtLine2.Scale, -angle);
//判断第一个点是否识别到已有要素边界
List<IFeature> IdentifyFeature = KGIS.Framework.AE.FeatureAPI.Identify(pMainLine.Line.get_Point(0), m_editor.TargetLayer, 1);
IdentifyFeature.AddRange(KGIS.Framework.AE.FeatureAPI.Identify(pExtLine1.Line.get_Point(0), m_editor.TargetLayer, 1));
IdentifyFeature.AddRange(KGIS.Framework.AE.FeatureAPI.Identify(pExtLine2.Line.get_Point(0), m_editor.TargetLayer, 1));
if (IdentifyFeature != null && IdentifyFeature.Count > 0)
{
IPolyline line = null;
//IFeature f = IdentifyFeature[0];
if (m_editor.GeometryType == esriGeometryType.esriGeometryPolygon)
{
foreach (IFeature item in IdentifyFeature)
{
ITopologicalOperator topo = item.ShapeCopy as ITopologicalOperator;
if (line == null)
{
line = topo.Boundary as IPolyline;
}
else
{
ITopologicalOperator topolog = line as ITopologicalOperator;
topolog.Simplify();
line = topolog.Union(topo.Boundary) as IPolyline;
}
}
IGeometryCollection geoCollection = line as IGeometryCollection;
if (geoCollection != null)
{
for (int i = 0; i < geoCollection.GeometryCount; i++)
{
if (KGIS.Framework.AE.FeatureAPI.IsInterSect(pMainLine.Line.get_Point(pMainLine.Line.PointCount - 1) as IGeometry, geoCollection.get_Geometry(i) as IPolyline))
{
line = geoCollection.get_Geometry(i) as IPolyline;
}
}
}
}
else if (m_editor.GeometryType == esriGeometryType.esriGeometryPolyline)
{
foreach (IFeature item in IdentifyFeature)
{
if (line == null)
{
line = item.ShapeCopy as IPolyline;
}
else
{
ITopologicalOperator topolog = line as ITopologicalOperator;
topolog.Simplify();
line = topolog.Union(item.ShapeCopy) as IPolyline;
}
}
}
if (line != null)
{
if (KGIS.Framework.AE.FeatureAPI.IsInterSect(pMainLine.Line.get_Point(0) as IGeometry, line))
{
ITopologicalOperator2 topo = line as ITopologicalOperator2;
IPoint p = GetIntersectPoint(pExtLine1EndPoint, pExtLine1StartPoint, line);
if (p != null && !p.IsEmpty && !IsContinueDraw)
{
pExtLine1StartPoint = p;
}
IPoint p2 = GetIntersectPoint(pExtLine2EndPoint, pExtLine2StartPoint, line);
if (p2 != null && !p2.IsEmpty && !IsContinueDraw)
{
pExtLine2StartPoint = p2;
}
}
}
}
}
else
{
pExtLine1StartPoint = GeometryOperations.getParallelPoint(pMainLine.Line.get_Point(pMainLine.Line.PointCount - 2), pMainLine.Line.get_Point(pMainLine.Line.PointCount - 1), pPoint, drawParam.Width * pExtLine1.Scale);
pExtLine2StartPoint = GeometryOperations.getParallelPoint(pMainLine.Line.get_Point(pMainLine.Line.PointCount - 2), pMainLine.Line.get_Point(pMainLine.Line.PointCount - 1), pPoint, drawParam.Width * pExtLine2.Scale);
}
if (!IsContinueDraw || pExtLine1.Line.PointCount > 1)
{
//更新第一条线上的点
pExtLine1.Line.UpdatePoint(pExtLine1.Line.PointCount - 1, pExtLine1StartPoint);
//更新第一条跟随线上的点
pExtLine1.FollowLine.Stop();
pExtLine1.FollowLine.Start(new PolylineClass() { FromPoint = pExtLine1StartPoint, ToPoint = pExtLine1StartPoint }, 0, pExtLine1StartPoint);
}
else
{
pExtLine1.FollowLine.Stop();
pExtLine1.FollowLine.Start(new PolylineClass() { FromPoint = pExtLine1.Line.get_Point(0), ToPoint = pExtLine1.Line.get_Point(0) }, 0, pExtLine1.Line.get_Point(0));
}
pExtLine1.FollowLine.MoveTo(GeometryOperations.GetPoint(pPoint, drawParam.Width * pExtLine1.Scale, -angle));
if (!IsContinueDraw || pExtLine1.Line.PointCount > 1)
{
//更新第二条线上的点
pExtLine2.Line.UpdatePoint(pExtLine1.Line.PointCount - 1, pExtLine2StartPoint);
//更新第二条跟随线上的点
pExtLine2.FollowLine.Stop();
pExtLine2.FollowLine.Start(new PolylineClass() { FromPoint = pExtLine2StartPoint, ToPoint = pExtLine2StartPoint }, 0, pExtLine2StartPoint);
}
else
{
pExtLine2.FollowLine.Stop();
pExtLine2.FollowLine.Start(new PolylineClass() { FromPoint = pExtLine2.Line.get_Point(0), ToPoint = pExtLine2.Line.get_Point(0) }, 0, pExtLine2.Line.get_Point(0));
}
pExtLine2.FollowLine.MoveTo(GeometryOperations.GetPoint(pPoint, drawParam.Width * pExtLine2.Scale, -angle));
//添加布尔型参数IsAdjustWidth使其为true时跳过刷新MainLine
if (IsAdjustWidth)
return;
if (!IsContinueDraw || pExtLine1.Line.PointCount > 1)
{
//更新主跟随线上的点
pMainLine.FollowLine.Stop();
pMainLine.FollowLine.Start(new PolylineClass() { FromPoint = pMainLine.Line.get_Point(pMainLine.Line.PointCount - 1), ToPoint = pMainLine.Line.get_Point(pMainLine.Line.PointCount - 1) }, 0, pMainLine.Line.get_Point(pMainLine.Line.PointCount - 1));
}
else
{
pMainLine.FollowLine.Stop();
pMainLine.FollowLine.Start(new PolylineClass() { FromPoint = pMainLine.Line.get_Point(0), ToPoint = pMainLine.Line.get_Point(0) }, 0, pMainLine.Line.get_Point(0));
}
pMainLine.FollowLine.MoveTo(pPoint);
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 移动现有的点 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 移动现有的点 时异常信息结束");
}
}
/// <summary>
/// 创建区间线段
/// </summary>
/// <param name="pLine">输入的线图形</param>
/// <param name="p1">插入的其中第一个点</param>
/// <param name="p2">插入的其中第一个点</param>
/// <returns>这两点间的线段</returns>
//[LogWrite(Description = "")]
private IPolyline BuildLine(IPolyline pLine, IPoint p1, IPoint p2)
{
bool isSplit;
int splitIndex, segIndex;
//插入第一点，segIndex记录插入点的相对线的节点位置
pLine.SplitAtPoint(p1, true, false, out isSplit, out splitIndex, out segIndex);
int fIndex = segIndex;
//插入第二点
pLine.SplitAtPoint(p2, true, false, out isSplit, out splitIndex, out segIndex);
int sIndex = segIndex;
IPointCollection pPointCol = new PolylineClass();
IPointCollection pPointCol2 = new PolylineClass();
object o = Type.Missing;
//比较一下插入第一点和第二点的节点次序
if (fIndex > sIndex)
{
int temp = fIndex;
fIndex = sIndex;
sIndex = temp;
}
else if (fIndex == sIndex)
{
pPointCol.AddPoint(p1, ref o, ref o);
pPointCol.AddPoint(p2, ref o, ref o);
return pPointCol as IPolyline;
}
//利用两点区间，获取线上区间所在的点，并将其转换为线
IPointCollection LineCol = pLine as IPointCollection;
for (int i = fIndex; i <= sIndex; i++)
{
pPointCol.AddPoint(LineCol.get_Point(i), ref o, ref o);
}
//for (int i = 0; i < LineCol.PointCount; i++)
//{
// if (i < fIndex || i > sIndex)
// {
// pPointCol2.AddPoint(LineCol.get_Point(i), ref o, ref o);
// }
//}
return pPointCol as IPolyline;
}
//private IPolyline GetSubCurve(IPolyline inpolyLine, IPoint pnt1, IPoint pnt2)
//{
// double d1 = GetDistAlong(inpolyLine, pnt1);
// double d2 = GetDistAlong(inpolyLine, pnt2);
// var c = inpolyLine as ICurve;
// ICurve outCurve;
// c.GetSubcurve(d1, d2, false, out outCurve);
// if (c == null || c.IsEmpty)
// throw new Exception("aa");
// var outPolyline = outCurve as IPolyline;
// if (outPolyline == null)
// {
// outPolyline = new PolylineClass() as IPolyline;
// var sc = outPolyline as ISegmentCollection;
// sc.AddSegment((ISegment)outCurve);
// ((IGeometry)sc).SpatialReference = outCurve.SpatialReference;
// }
// return outPolyline;
//}
//[LogWrite(Description = "")]
private double GetDistAlong(IPolyline polyLine, IPoint pnt)
{
var outPnt = new PointClass() as IPoint;
double distAlong = double.NaN;
double distFrom = double.NaN;
bool bRight = false;
polyLine.QueryPointAndDistance(esriSegmentExtension.esriNoExtension, pnt, false, outPnt,
ref distAlong, ref distFrom, ref bRight);
return distAlong;
}
/// <summary>
/// 绘制点对象到地图
/// </summary>
/// <param name="pPoints"></param>
//[LogWrite(Description = "")]
private void DrawPoint(IPointCollection pPoints)
{
try
{
if (pPoints == null || pPoints.PointCount == 0)
return;
// 获取IRGBColor接口
IRgbColor color = new RgbColor();
// 设置颜色属性
color.Red = 255;
color.Green = 0;
color.Blue = 0;
IMarkerSymbol symbol = new SimpleMarkerSymbolClass();
symbol.Color = color;
symbol.Size = 5;
IPointCollection pointList = new Polyline();
pointList.AddPoint(this.LeftLine.Line.get_Point(this.LeftLine.Line.PointCount - 1));
pointList.AddPoint(this.MiddleLine.Line.get_Point(this.MiddleLine.Line.PointCount - 1));
pointList.AddPoint(this.RightLine.Line.get_Point(this.RightLine.Line.PointCount - 1));
IPointCollection pointList2 = new Polyline();
pointList2.AddPoint(this.LeftLine.Line.get_Point(this.LeftLine.Line.PointCount - 1));
pointList2.AddPoint(this.MiddleLine.Line.get_Point(this.MiddleLine.Line.PointCount - 1));
pointList2.AddPoint(this.RightLine.Line.get_Point(this.RightLine.Line.PointCount - 1));
for (int i = 0; i < pPoints.PointCount; i++)
{
if (PointElement.Count == i)
{
IMarkerElement e = new MarkerElementClass();
e.Symbol = symbol;
PointElement.Add(e as IElement);
this.m_hookHelper.ActiveView.GraphicsContainer.AddElement(e as IElement, 0);
}
IElement element = PointElement[i];
pointList.AddPoint(element.Geometry as IPoint);
element.Geometry = pPoints.get_Point(i);
pointList2.AddPoint(pPoints.get_Point(i));
}
pointList.AddPoint(this.LeftLine.Line.get_Point(this.LeftLine.Line.PointCount - 1));
IPolyline line = pointList as IPolyline;
if (line.Length <= 0 || line.Length.Equals(double.NaN))
{
return;
}
ITopologicalOperator topo = line as ITopologicalOperator;
IGeometry geo = topo.Buffer(10);
this.m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGraphics, null, this.m_hookHelper.ActiveView.Extent);
//this.m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, geo.Envelope);
//this.m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, (pointList2 as IPolyline).Envelope);
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 绘制点对象到地图 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 绘制点对象到地图 时异常信息结束");
}
}
/// <summary>
/// 绘制文本对象
/// </summary>
/// <param name="geoDraw"></param>
/// <param name="pElement"></param>
//[LogWrite(Description = "")]
public void DrawTextElement(ESRI.ArcGIS.Geometry.IGeometry geoDraw, ref IElement pElement)
{
if (pElement != null && geoDraw != null)
{
if (pElement is ITextElement)
{
(pElement as ITextElement).Text = string.Format("当前宽度 {0} 米", drawParam.Width);
}
pElement.Geometry = geoDraw;
m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGraphics, null, m_hookHelper.ActiveView.Extent);
return;
}
// 获取IRGBColor接口
IRgbColor color = new RgbColor();
// 设置颜色属性
color.Red = 0;
color.Green = 255;
color.Blue = 255;
//IFontDisp pFont = new StdFont()
//{
// Name = "宋体",
// Bold = true
//} as IFontDisp;
ITextSymbol pTextSymbol = new TextSymbolClass()
{
Color = color,
//Font = pFont,
Size = 12
};
ITextElement pTextElement = new TextElementClass()
{
Symbol = pTextSymbol,
ScaleText = true,
Text = string.Format("当前宽度 {0} 米", drawParam.Width)
};
IPoint point = geoDraw as IPoint;
point.X += 2;
point.Y -= 1;
if (pElement == null)
{
pElement = pTextElement as IElement;
pElement.Geometry = point;
m_hookHelper.ActiveView.GraphicsContainer.AddElement(pElement, 0);
}
m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGraphics, null, m_hookHelper.ActiveView.Extent);
}
/// <summary>
/// 删除指定的Element
/// </summary>
/// <param name="pElement"></param>
//[LogWrite(Description = "")]
public void DelElement(ref IElement pElement)
{
try
{
if (pElement != null)
{
m_hookHelper.ActiveView.GraphicsContainer.DeleteElement(pElement);
m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGraphics, null, m_hookHelper.ActiveView.Extent);
pElement = null;
}
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 删除指定的Element 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 删除指定的Element 时异常信息结束");
}
}
/// <summary>
/// 捕捉Element上的点并返回点的索引
/// </summary>
/// <param name="pPoint"></param>
/// <returns></returns>
//[LogWrite(Description = "")]
private int SnapElement(IPoint pPoint)
{
int pointIndex = -1;
try
{
//中心线距离
double len = -1;
for (int i = 0; i < MiddleLine.Line.PointCount; i++)
{
IPolyline line = new PolylineClass();
line.FromPoint = MiddleLine.Line.get_Point(i);
line.ToPoint = pPoint;
line.SpatialReference = pPoint.SpatialReference;
if (len == -1)
{
len = line.Length;
pointIndex = i;
}
else
{
if (len > line.Length)
{
len = line.Length;
pointIndex = i;
}
}
}
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 捕捉Element上的点并返回点的索引 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 捕捉Element上的点并返回点的索引 时异常信息结束");
return -1;
}
return pointIndex;
}
/// <summary>
/// 捕捉Element上的点并返回点的索引
/// </summary>
/// <param name="pPoint"></param>
/// <returns></returns>
//[LogWrite(Description = "")]
private int SnapElement(IPoint pPoint, out int p)
{
int pointIndex = -1;
try
{
double tempLen = -1;
//中心线距离
double len = -1;
//左边线距离
double len1 = -1;
//右边线距离
double len2 = -1;
//中心线索引
int m_index = -1;
//左边线索引
int l_index = -1;
//右边线索引
int r_index = -1;
for (int i = 0; i < MiddleLine.Line.PointCount; i++)
{
IPolyline line = new PolylineClass();
line.FromPoint = MiddleLine.Line.get_Point(i);
line.ToPoint = pPoint;
line.SpatialReference = pPoint.SpatialReference;
if (len == -1)
{
len = line.Length;
m_index = i;
}
else
{
if (len > line.Length)
{
len = line.Length;
m_index = i;
}
}
}
for (int i = 0; i < LeftLine.Line.PointCount; i++)
{
IPolyline line = new PolylineClass();
line.FromPoint = LeftLine.Line.get_Point(i);
line.ToPoint = pPoint;
line.SpatialReference = pPoint.SpatialReference;
if (len1 == -1)
{
len1 = line.Length;
l_index = i;
}
else
{
if (len1 > line.Length)
{
len1 = line.Length;
l_index = i;
}
}
}
for (int i = 0; i < RightLine.Line.PointCount; i++)
{
IPolyline line = new PolylineClass();
line.FromPoint = RightLine.Line.get_Point(i);
line.ToPoint = pPoint;
line.SpatialReference = pPoint.SpatialReference;
if (len2 == -1)
{
len2 = line.Length;
r_index = i;
}
else
{
if (len2 > line.Length)
{
len2 = line.Length;
r_index = i;
}
}
}
if (len > len1)
{
if (len1 > len2)
{
p = -1;
tempLen = len2;
pointIndex = r_index;
}
else
{
p = 1;
tempLen = len1;
pointIndex = l_index;
}
}
else
{
if (len > len2)
{
p = -1;
tempLen = len2;
pointIndex = r_index;
}
else
{
p = 0;
tempLen = len;
pointIndex = m_index;
}
}
if (tempLen > 3)
{
pointIndex = -1;
}
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 在捕捉Element上的点并返回点的索引 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 在捕捉Element上的点并返回点的索引 时异常信息结束");
p = 0;
return -1;
}
return pointIndex;
}
//[LogWrite(Description = "")]
private IPolyline GetSubCurve(IPolyline LineCurve, IPoint SplitePoint1, IPoint SplitePoint2)
{
IPolyline Lines = null;
bool isSplit;
int splitIndex, segStartIndex, segEndIndex, minIndex, maxIndex;
LineCurve.SplitAtPoint(SplitePoint1, true, false, out isSplit, out splitIndex, out segStartIndex);
LineCurve.SplitAtPoint(SplitePoint2, true, false, out isSplit, out splitIndex, out segEndIndex);
if (isSplit)
{
IPolyline newLine = new PolylineClass();
ISegmentCollection lineSegCol = (ISegmentCollection)LineCurve;
ISegmentCollection newSegCol = (ISegmentCollection)newLine;
object o = Type.Missing;
if (segStartIndex > segEndIndex)
{
minIndex = segEndIndex;
maxIndex = segStartIndex;
}
else
{
minIndex = segStartIndex;
maxIndex = segEndIndex;
}
for (int j = minIndex; j <= maxIndex; j++)
{
ISegment segment = lineSegCol.get_Segment(j);
//if ((Math.Round(segment.FromPoint.X, 4) == Math.Round(SplitePoint1.X, 4) && Math.Round(segment.FromPoint.Y, 4) == Math.Round(SplitePoint1.Y, 4) && Math.Round(segment.ToPoint.X, 4) == Math.Round(SplitePoint2.X, 4) && Math.Round(segment.ToPoint.Y, 4) == Math.Round(SplitePoint2.Y, 4))
// || (Math.Round(segment.ToPoint.X, 4) == Math.Round(SplitePoint1.X, 4) && Math.Round(segment.ToPoint.Y, 4) == Math.Round(SplitePoint1.Y, 4) && Math.Round(segment.FromPoint.X, 4) == Math.Round(SplitePoint2.X, 4) && Math.Round(segment.FromPoint.Y, 4) == Math.Round(SplitePoint2.Y, 4)))
//{
newSegCol.AddSegment(segment, ref o, ref o);
//Lines = newSegCol as IPolyline;
//break;
//}
}
Lines = newSegCol as IPolyline;
}
return Lines;
}
//[LogWrite(Description = "")]
public IPolyline GeneratePolyline(IPoint point)
{
IPolyline result = null;
if (point == null) return result;
try
{
List<IFeatureLayer> snapLayers = new List<IFeatureLayer>();
snapLayers.Add(m_editor.TargetLayer as IFeatureLayer);
//获取当前捕捉的要素多边形
List<IFeature> snapFeatures = FeatureAPI.Snapping(point, snapLayers, 10);
if (snapFeatures == null) return result;
foreach (IFeature feautre in snapFeatures)
{
//将多边形要素转成线要素
List<IGeometry> featureToLines = FeatureAPI.PolygonToLine(feautre.ShapeCopy);
if (featureToLines == null) continue;
IPolyline tempLine = null;
foreach (IGeometry f_line in featureToLines)
{
tempLine = f_line as IPolyline;
List<IFeature> LineInsertFeature = FeatureAPI.Snapping(tempLine, snapLayers, 0.0001);
foreach (IFeature item in LineInsertFeature)
{
if (item.OID == feautre.OID)
continue;
ITopologicalOperator topo = tempLine as ITopologicalOperator;
topo.Simplify();
IPolyline newline = topo.Intersect(item.ShapeCopy, esriGeometryDimension.esriGeometry1Dimension) as IPolyline;
//IPolyline obj = result.Values.FirstOrDefault(f => Math.Round(f.Length, 0) == Math.Round(newline.Length, 0));
if (FeatureAPI.IsInterSect(point as IGeometry, newline))
{
result = newline;
return result;
}
tempLine = topo.Difference(item.ShapeCopy) as IPolyline;
}
}
if (FeatureAPI.IsInterSect(point as IGeometry, tempLine))
{
result = tempLine;
break;
}
}
return result;
}
catch (Exception ex)
{
LogAPI.Debug("画线物面（线状地物面）工具 过程中 执行 GeneratePolyline 时异常，异常信息如下：");
LogAPI.Debug(ex);
LogAPI.Debug("画线物面（线状地物面）工具 过程中 执行 GeneratePolyline 时异常信息结束");
throw;
}
}
#endregion
/// <summary>
/// 设置鼠标的坐标
/// </summary>
/// <param name="x">横坐标</param>
/// <param name="y">纵坐标</param>
[DllImport("User32")]
public extern static void SetCursorPos(int x, int y);
//[LogWrite(Description = "")]
//private bool ss()
//{
// try
// {
// if (Env.Instance.KeyType != "F")//非本地授权 直接返回
// {
// return true;
// }
// RunIDHelper id = new RunIDHelper();
// return id.QCCheck();
// }
// catch
// {
// return false;
// }
//}
public override void Refresh(int hDC)
{
if (MiddleLine != null && MiddleLine.FollowLine != null)
MiddleLine.FollowLine.Refresh(hDC);
if (LeftLine != null && LeftLine.FollowLine != null)
LeftLine.FollowLine.Refresh(hDC);
if (RightLine != null && RightLine.FollowLine != null)
RightLine.FollowLine.Refresh(hDC);
base.Refresh(hDC);
}
}
}