OTS/OTSIncAMeasureApp/4-OTSSamplespaceGraphicsPanel/OTSSamplespaceWindow.cs

using MyControls;
using OTS.WinFormsUI.Docking;
using OTSDataType;
using OTSMeasureApp._0_OTSModel.OTSDataType;
using OTSMeasureApp._4_OTSSamplespaceGraphicsPanel;
using OTSMeasureApp._4_OTSSamplespaceGraphicsPanel.VisualGDIObjects;
using OTSModelSharp;
using OTSModelSharp.ServiceCenter;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;


namespace OTSMeasureApp
{
    public enum EnumMousePointPosition
    {
        MouseSizeNone = 0, //'无  
        MouseSizeRight = 1, //'拉伸右边框  
        MouseSizeLeft = 2, //'拉伸左边框  
        MouseSizeBottom = 3, //'拉伸下边框  
        MouseSizeTop = 4, //'拉伸上边框  
        MouseSizeTopLeft = 5, //'拉伸左上角  
        MouseSizeTopRight = 6, //'拉伸右上角  
        MouseSizeBottomLeft = 7, //'拉伸左下角  
        MouseSizeBottomRight = 8, //'拉伸右下角  
        MouseDrag = 9   // '鼠标拖动  
    }
    public enum ContextMenuType
    {
        //样品孔右键菜单
        SampleHoleMenu = 0,
        //样品右键菜单
        SampleMenu = 1,
        //测量区域右键菜单
        MeasureMenu = 2,
        //线程运行后菜单
        ThreadRunMenu = 3,
        //样品台右键菜单
        SampleStateMenu = 4,
        //样品孔BSE图像
        SampleHoleBSEImage = 5,
        //帧图菜单
        FieldMenu = 6
    }
    public enum MenuIndex
    {
        AddSample = 0,
        DeleteSample = 1,
        SampleStripSeparator = 2,
        ReadSEMData = 3,
        SetSemData = 4,
        SetSEMCenterLocation = 5,
        DriveSEMToCenterLocation = 6,
        DriveSEMToCurrentLocation = 7,
        SEMStripSeparator = 8,
        ShootBSEPicture = 9,
        DeleteBSEPicture = 10,
        DeleteSampleData = 11,
        SlopFocus = 12
    }


    public enum DrawMeasureAreaActionType
    {
        NoAction = 1,
        //圆形
        Circle = 2,


        Rectangle = 3,



        //多边形
        Polygon = 4,

        //圆形三点法
        CircleByThreePoints = 5,

        InverseSelection = 6


    }
    public partial class OTSSamplespaceWindow : DockContent
    {
        #region 全局变量定义

        public CVisualStage m_visualStage;


        string m_SampleHoleSelectName = string.Empty;
        public string m_SampleSelectName = string.Empty;


        public List<CVisualSampleArea> m_visualSamples;


        //手绘测量区域
        public static CMeasureArea m_DrawMeasureGDIObject = new CMeasureArea();

        //多边形测量区域完成标识
        public static CDisplayGDIObject m_DrawPolygonFinishGDIObject;

        //主窗体对象
        OTSIncAMeasureAppForm m_MeasureAppForm;

        SEMDATAFieldManage m_SEMDATAFieldManage;


        private _5_OTSMeasureStatuImageFun.SlopFocus slopFocus = null;

        const float m_PenWidth = 5;

        const int m_MinMeasureWidthValue = 20;
        //点数量
        const int m_PolygonMinPointCount = 2;

        //与多边形绘制的开始点相差的像素值
        const int m_OffsetPX = 10;
        //默认值
        const int m_DValue = 1;



        #region 手动绘制测量区域
        Point m_MouseDownPoint;

        Point m_MouseMovePoint;


        //手动绘制多边形测量区域完成标识
        bool m_IsDrawPolygonFinish = false;
        //手动绘制测量区域的形状类型
        DrawMeasureAreaActionType m_DrawMeasureType = DrawMeasureAreaActionType.NoAction;

        //是否手绘标识
        bool m_IsDrawMeasure = false;
        #endregion


        #endregion

        NLog.Logger log;
        #region 标尺变量

        //最小缩放倍数
        const float f_zoom_mix = 0.5f;

        //标尺的大小记录
        private float f_ruler_size = 100;

        //标尺原先大小的记录，参与计算
        private float f_old_ruler_size = 100;


        #endregion
        //国际化
        OTSCommon.Language lan;
        Hashtable table;
        public CDisplayGDIObject sampleHoleImageBuffer;
        #region 设置双缓冲
        /// <summary>
        /// 设置双缓冲
        /// </summary>
        public void SetDoubleBufferByIsDraw()
        {
            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true); // 禁止擦除背景.
            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true); // 双缓冲
        }
        #endregion
        CFieldPositionHelper pFieldMgr = new CFieldPositionHelper();


        #region 构造函数 获取父窗体对象
        public OTSSamplespaceWindow(OTSIncAMeasureAppForm MeasureAppForm)
        {
            InitializeComponent();
            m_MeasureAppForm = MeasureAppForm;

            SetDoubleBufferByIsDraw();// 双缓冲


            //国际化
            lan = new OTSCommon.Language(this);
            table = lan.GetNameTable(this.Name);
        }
        #region 菜单操作
        private void CMStrip_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            Point mousePoint = this.PointToClient(Control.MousePosition);
            CMStrip.Hide();
            switch (e.ClickedItem.Name)
            {
                case "AddStage":


                    //添加样品
                    m_MeasureAppForm.AddNewSampleMeasure(m_SampleHoleSelectName);

                    break;


                case "DeleteStage":
                    //删除样品
                    DeleteSampleInfo(m_SampleSelectName);
                    break;
                case "DriveSEMToCenterLocation":
                    //驱动SEM到中心位置
                    SetSEMToCenterPoint();
                    ReadSEMDataAndSetToCurrentSample();
                    PrepareMeasureField(GetWorkingVisualSample(), MSR_RUN_TYPE.RUNMEASURE);
                    break;
                case "DriveSEMToCurrentLocation":
                    //驱动SEM到当前位置
                    SetSEMCurrentLocation();
                    ReadSEMDataAndSetToCurrentSample();
                    PrepareMeasureField(GetWorkingVisualSample(), MSR_RUN_TYPE.RUNMEASURE);
                    break;
                case "SetSEMCenterLocation":
                    //将测量区域移到SEM当前位置
                    SetMeasureToSEMLocation();
                    ReadSEMDataAndSetToCurrentSample();
                    PrepareMeasureField(GetWorkingVisualSample(), MSR_RUN_TYPE.RUNMEASURE);
                    break;
                case "ReadSEMData":
                    m_MeasureAppForm.SetRunType(MSR_RUN_TYPE.RUNMEASURE);

                    ReadSEMDataAndSetToCurrentSample();
                    PrepareMeasureField(GetWorkingVisualSample(), MSR_RUN_TYPE.RUNMEASURE);

                    break;
                case "SetSemData":
                    double SemMag = 0;
                    double dDistance = 0;
                    double bri = 0;
                    double contra = 0;
                    double kv = 0;
                    if (m_MeasureAppForm.m_ProjParam.GetWorkingSampleSEMData(ref dDistance, ref SemMag, ref bri, ref contra, ref kv))
                    {
                        //设置SEM数据

                        if (!SetSEMDATAMParameter(SemMag, dDistance, bri, contra))
                        {
                            log.Error("Failed SetSemData:--Mag:" + SemMag + "--Distance:" + dDistance + "--");
                        }
                    }
                    break;
                case "ShootBSEPicture":
                    //设置消息类型 拍摄样品孔
                    m_MeasureAppForm.SetRunType(MSR_RUN_TYPE.RUNSampleHoleImage);


                    PrepareMeasureField(GetWorkingVisualSample(), MSR_RUN_TYPE.RUNSampleHoleImage);

                    m_MeasureAppForm.StartSampleHoleBSEImage();
                    break;
                case "DeleteBSEPicture":
                    DeleteHoleBSEImageDataNoMessageBox();
                    break;
                case "DeleteSampleData":
                    try
                    {
                        var frmFieldStart = new frmInitializeStartInput();
                        frmFieldStart.ShowDialog();
                        if (frmFieldStart.okcancel == true)
                        {
                            InitSampleMeasure(m_MeasureAppForm.m_ProjParam.GetWorkSample(), frmFieldStart.fieldStartNo);

                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.ToString());
                    }

                    break;
                case "SlopFocusMenuItem":

                    if (slopFocus == null)
                    {
                        slopFocus = new _5_OTSMeasureStatuImageFun.SlopFocus(this);
                    }

                    slopFocus.Show();

                    break;
            }
        }
        #endregion

        public void InitSampleMeasure(COTSSample smpl, int fieldStartNo)

        {
            m_MeasureAppForm.m_ProjParam.SetWorkSample(smpl.GetName());
            m_MeasureAppForm.m_ProjParam.InitWorkingSampleData(fieldStartNo);
            m_MeasureAppForm.InitCurrentSampleState();
            m_MeasureAppForm.m_MsrThreadWrapper.m_measure.mapSmplMsr.Clear();

            var visualsam = GetWorkingVisualSample();
            var sam = m_MeasureAppForm.m_ProjRstData.GetWorkingSample();
            var allflds = sam.GetFieldsData();

            foreach (var f in allflds)
            {
                if (f.GetMeasureSequence() >= fieldStartNo)
                {
                    Color ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.FieldColor);
                    ChangeMeasureFieldColor(visualsam, f.GetOTSPosition(), ColorStr);

                }

            }


            m_MeasureAppForm.m_MeasureResultWindow.UpdateResultInfoBySampleName(sam.GetName());



        }
        /// <summary>
        /// 画圆形测试区域 事件
        /// </summary>
        public void DrawCircleMeasure()
        {
            //手绘测量区域类型为圆形
            m_DrawMeasureType = DrawMeasureAreaActionType.Circle;
            m_IsDrawMeasure = true;
            m_DrawMeasureGDIObject = null;
            this.Cursor = Cursors.Hand;
        }
        /// <summary>
        /// 画矩形测试区域 事件
        /// </summary>
        public void DrawRectangleMeasure()
        {
            //手绘测量区域类型为矩形
            m_DrawMeasureType = DrawMeasureAreaActionType.Rectangle;

            m_IsDrawMeasure = true;
            m_DrawMeasureGDIObject = null;
            this.Cursor = Cursors.Hand;
        }
        /// <summary>
        /// 画多边形测试区域 事件
        /// </summary>
        public void DrawPolygonMeasure()
        {
            m_DrawMeasureType = DrawMeasureAreaActionType.Polygon;
            m_IsDrawMeasure = true;
            //m_DrawMeasureGDIObject = null;
            m_DrawMeasureGDIObject = new CMeasureArea(new List<PointF>(), ShapeType.POLYGON, "", "", Color.Red);

            this.Cursor = Cursors.Hand;
        }

        /// <summary>
        /// 三点画圆形测试区域 事件  先多边形后圆形
        /// </summary>
        public void DrawCircleMeasureByThreePoints()
        {
            //手绘测量区域类型为圆形
            m_DrawMeasureType = DrawMeasureAreaActionType.CircleByThreePoints;
            m_IsDrawMeasure = true;
            m_DrawMeasureGDIObject = null;
            this.Cursor = Cursors.Hand;
        }
        public void DrawRingShapeArea()
        {
            //手绘测量区域类型为圆形
            //m_DrawMeasureType = CreateRectangleType.RingShape;
            RingGdiDataInput frmInput = new RingGdiDataInput();
            if (frmInput.ShowDialog() == DialogResult.OK)
            {
                float diameter = (float)m_visualStage.MicronConvertToPixel(frmInput.Diameter);
                float ringwidth = (float)m_visualStage.MicronConvertToPixel(frmInput.RingWidth);
                var sam = GetWorkingVisualSample();
                SizeF size = new SizeF(diameter, diameter);
                var position = sam.GetMeasureGDIObject().GetZoomedRegionF().Location;
                RectangleF rec = sam.GetMeasureGDIObject().GetZoomedRegionF();
                PointF centerPos = new PointF(position.X + rec.Width / 2, position.Y + rec.Height / 2);
                PointF newRegionFPos = new PointF(centerPos.X - diameter / 2, centerPos.Y - diameter / 2);
                RectangleF rectangle = new RectangleF(newRegionFPos, size);
                Color MeasureColor = Color.Red;
                CRingGDIObject newGDI;

                newGDI = new CRingGDIObject(rectangle, sam.GetSampleGDIObject().NameOrHoleName, sam.GetSampleName(), MeasureColor);
                newGDI.SetRingWidth(ringwidth);

                newGDI.SetZoomNumber(m_visualStage.GetZoomNum());
                newGDI.SetDisplayRefPoint(m_visualStage.GetDisplayRefPoint());

                newGDI.IsWorkSample = true;


                sam.SetMeasureGDIObject(newGDI);


                m_DrawPolygonFinishGDIObject = null;
                m_DrawMeasureGDIObject = null;

                var para = m_visualStage.GetSampleMeasurePara(sam.GetMeasureGDIObject());

                m_MeasureAppForm.m_ProjParam.SetWorkSampleHoleAndMeasureArea(para);


            }




        }

        public CVisualSampleArea GetWorkingVisualSample()
        {

            foreach (var s in m_visualSamples)
            {
                if (s.IsWorkSample())
                {
                    return s;
                }

            }
            return null;
        }
        public CVisualSampleArea GetVisualSampleByName(string name)
        {
            foreach (var s in m_visualSamples)
            {
                if (s.GetSampleName() == name)
                {
                    return s;
                }

            }
            return null;



        }
        public void DisplayVisualStage(CStage SStage, CSEMStageData SEMStageData)
        {
            m_visualStage.clear();
            m_visualStage.InitSampleStageData(SStage, SEMStageData, this.Width, this.Height);
            m_visualStage.DrawSampleStage();
        }

        public void DisplayExistSamples(List<SampleMeasurePara> SMeasrueParaList)
        {

            foreach (var SMeasrueArea in SMeasrueParaList)
            {
                DisplaySample(SMeasrueArea);

            }

            SwitchWorkSample(SMeasrueParaList[0].sSampleName);
            m_SampleSelectName = SMeasrueParaList[0].sSampleName;

            //重新绘制
            Invalidate();
        }
        public void DisplaySample(SampleMeasurePara SMeasrueArea)
        {
            var m_Sample = m_MeasureAppForm.m_ProjParam.GetResultData().GetSampleByName(SMeasrueArea.sSampleName);
            var FldDatas = m_Sample.GetFieldsData();
            if (FldDatas.Count == 0)
            {
                //this part code is to be compatible with previouse version result file which there's no AllField position info.
                DrawSampleAndMeasureInfo(SMeasrueArea);

            }
            else
            {
                var item = m_visualStage.GetHoleGDIByHoleName(SMeasrueArea.sampleHoleName);
                if (item != null)
                {
                    CVisualSampleArea sam;
                    if (InitVisualSample(SMeasrueArea.sampleHoleName, SMeasrueArea.sSampleName, out sam))
                    {
                        if (SMeasrueArea.iShape == ShapeType.POLYGON)
                        {
                            var ps = new List<PointF>();
                            foreach (var p in SMeasrueArea.DrawPolygonPointList)
                            {
                                var ctrlcoordPoint = m_visualStage.OTSCoordToCtrlCoord(p);
                                ps.Add(ctrlcoordPoint);

                            }

                            CMeasureArea polygonGdi = new CMeasureArea(ps, ShapeType.POLYGON, SMeasrueArea.sampleHoleName, SMeasrueArea.sSampleName, Color.Red);


                            sam.SetMeasureGDIObject(polygonGdi);


                        }
                        else
                        {
                            PointF xHole = new PointF(SMeasrueArea.MeasureRect.Left, SMeasrueArea.MeasureRect.Top);
                            PointF yHole = new PointF(SMeasrueArea.MeasureRect.Right, SMeasrueArea.MeasureRect.Bottom);
                            CDisplayGDIObject gdi = m_visualStage.GetCtrlCoordRect(xHole, yHole, (GDIType)SMeasrueArea.iShape, "", "");
                            gdi.SampleName = SMeasrueArea.sSampleName;
                            gdi.NameOrHoleName = SMeasrueArea.sampleHoleName;
                            //gdi.Shape = SMeasrueArea.iShape;
                            CMeasureArea measureGdi;
                            if (m_visualStage.GetMeasureGdiObjectFromSampleGdi(gdi, out measureGdi))
                            {

                                sam.SetMeasureGDIObject(measureGdi);

                            }
                        }


                        List<CVisualFieldGDIObject> visualfieldRects = new List<CVisualFieldGDIObject>();

                        foreach (var fld in FldDatas)
                        {


                            float micronWidth = (float)fld.GetOTSRect().GetWidth();
                            float micronHeight = (float)fld.GetOTSRect().GetHeight();

                            var fldRect = new RectangleF(new PointF(fld.GetOTSPosition().X - micronWidth / 2, fld.GetOTSPosition().Y - micronHeight / 2), new SizeF(micronWidth, micronHeight));

                            PointF lt = new PointF(fldRect.Left, fldRect.Top);
                            PointF rb = new PointF(fldRect.Right, fldRect.Bottom);
                            RectangleF visualRect = m_visualStage.GetCtrlCoordRectF(lt, rb);

                            var ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.FieldColor);


                            string sampleName = sam.GetSampleName();
                            string sampleHoleName = sam.GetSampleGDIObject().NameOrHoleName;


                            CVisualFieldGDIObject createRect = new CVisualFieldGDIObject(visualRect, (int)fld.GetOTSPosition().X, (int)fld.GetOTSPosition().Y, sampleHoleName, sampleName, ColorStr);
                            createRect.Enable = fld.Enable;
                            visualfieldRects.Add(createRect);

                        }

                        sam.GetMeasureGDIObject().SubItems().Clear();


                        foreach (var r in visualfieldRects)
                        {

                            sam.AddFieldGDIObject(r);

                        }

                        COTSMsrPrjResultData cProjMgr = m_MeasureAppForm.m_ProjParam.GetResultData();

                        List<PointF> CompleteFieldList = cProjMgr.GetSampleByName(SMeasrueArea.sSampleName).GetMsrStatus().GetCompletedFieldsCenter();
                        if (CompleteFieldList.Count > 0)
                        {
                            ChangeCompleteFieldMeasureState(CompleteFieldList, Color.Green, sam);
                        }
                    }
                }



            }

        }

        public void SwitchWorkSample(string sNewWSampleName, bool bDrawField = false)
        {
            try
            {
                for (int i = 0; i < m_visualSamples.Count; i++)
                {
                    //获取颜色
                    if (m_visualSamples[i].GetSampleName() == sNewWSampleName)
                    {
                        var theColor = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleSelColor);
                        m_visualSamples[i].GetSampleGDIObject().SelColor = theColor;
                        m_visualSamples[i].SetIsWorkSample(true);
                    }
                    else
                    {
                        var SampleColor = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleColor);
                        m_visualSamples[i].GetSampleGDIObject().SelColor = SampleColor;
                        m_visualSamples[i].SetIsWorkSample(false);

                    }

                }

                m_IsDrawMeasure = false;
                this.Invalidate();
                return;
            }
            catch (Exception ex)
            {

                log.Trace(ex.ToString());
            }
        }
        public void ChangeCompleteFieldMeasureState(List<PointF> CompleteFieldList, Color changeColor, CVisualSampleArea vsSam)
        {

            foreach (var p in CompleteFieldList)
            {
                ChangeMeasureFieldColor(vsSam, p, changeColor);

            }

        }
        public void ChangeMeasureFieldColor(CVisualSampleArea vsSam, PointF CurrentFIELDOTSPoint, Color changeColor)
        {



            foreach (var gdi in vsSam.GetMeasureFieldGDIObjects())
            {
                var fieldPoint = m_visualStage.OTSCoordToCtrlCoord(new PointF((float)CurrentFIELDOTSPoint.X, (float)CurrentFIELDOTSPoint.Y));


                if (gdi.IfContains(fieldPoint))
                {
                    //修改完成状态
                    gdi.SelColor = changeColor;
                    break;
                }
            }

        }



        public void ChangeWorkSampleName(string sNewWSampleName)
        {


            //更换样品名称
            var sam = GetWorkingVisualSample();
            sam.SetSampleName(sNewWSampleName);
            this.Invalidate();
            return;

        }
        public void SetMeasureState(Color setColor)
        {
            foreach (var items in m_visualSamples)
            {
                items.GetMeasureGDIObject().SelColor = setColor;
            }
        }
        #endregion


        public void SetSampleState(Color setColor)
        {
            foreach (var items in m_visualSamples)
            {
                if (items.GetSampleGDIObject().IsDragging)
                {
                    //设置颜色
                    var ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleSelColor);
                    items.GetSampleGDIObject().SelColor = ColorStr;
                }
                else
                {
                    items.GetSampleGDIObject().SelColor = setColor;
                }
            }
        }

        public bool DeleteSample(string SampleName)
        {

            var sam = GetVisualSampleByName(SampleName);
            m_visualStage.DecreaseSampleCount(SampleName);
            m_visualSamples.Remove(sam);


            var ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleColor);
            SetSampleState(ColorStr);
            SetMeasureState(ColorStr);



            return false;
        }


        public void DeleteWorkSample(string sDeleteWSampleName)
        {
            try
            {
                DeleteSample(sDeleteWSampleName);

            }
            catch (Exception ex)
            {

                log.Error(ex.ToString());
            }
        }

        #region 更改工作样品中 测量区域形状

        public void changeShape(ShapeType iShape)
        {
            try
            {
                string sampleName = m_MeasureAppForm.m_ProjParam.GetWorkSampleName();
                //m_Shap 更换样品形状

                var sam = GetWorkingVisualSample();

                var itemMeasure = sam.GetMeasureGDIObject();
                itemMeasure.Myshape = iShape;


                var sampleMeasurePara = m_visualStage.GetSampleMeasurePara(sam.GetMeasureGDIObject());

                m_MeasureAppForm.m_ProjParam.SetWorkSampleHoleAndMeasureArea(sampleMeasurePara);


                PrepareMeasureField(sam, m_MeasureAppForm.GetRunType());


                this.Invalidate();
                return;
            }
            catch (Exception ex)
            {

                log.Error(ex.ToString());
            }
        }
        #endregion




        public void AddSampleArea(SampleMeasurePara SMeasurePara)
        {

            try
            {
                CMStrip.Hide();

                CVisualSampleArea sam;
                //添加样品
                foreach (var itemSample in m_visualSamples)
                {
                    //设置颜色
                    var ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleColor);
                    itemSample.GetSampleGDIObject().SelColor = ColorStr;
                    itemSample.SetIsWorkSample(false);
                }

                if (m_visualStage.GetVisualSampleArea(SMeasurePara, out sam))
                {

                    sam.SetIsWorkSample(true);
                    m_visualSamples.Add(sam);

                    m_SampleSelectName = SMeasurePara.sSampleName;

                    var para = m_visualStage.GetSampleMeasurePara(sam.GetMeasureGDIObject());

                    //var para = SMeasurePara;
                    m_MeasureAppForm.m_ProjParam.SetWorkSampleHoleAndMeasureArea(para);

                    Invalidate();

                }
            }
            catch (Exception ex)
            {

                log.Error(ex.ToString());
            }
        }
        public bool InitVisualSample(string SampleHoleNo, string SampleName, out CVisualSampleArea outsample)
        {


            CDisplayGDIObject itemAdd;
            //设置样品选择状态为非工作样品
            foreach (var Sample in m_visualSamples)
            {
                var itemSample = Sample.GetSampleGDIObject();
                //设置颜色
                var ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleColor);
                itemSample.SelColor = ColorStr;
                itemSample.IsWorkSample = false;
            }

            itemAdd = m_visualStage.GetHoleGDIByHoleName(SampleHoleNo);
            if (itemAdd != null)
            {
                //获取样品台类型
                //var shape = itemAdd.Shape;
                //设置颜色
                var ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleSelColor);
                Color selColor = ColorStr;
                CDisplayGDIObject sample = new CDisplayGDIObject(itemAdd.GetOrigionalDrawRegionF(), itemAdd.GDIType, itemAdd.NameOrHoleName, selColor);
                //累加样品数量
                itemAdd.SampleCount += 1;
                itemAdd.IsWorkSample = true;
                sample.SampleName = SampleName;
                sample.NameOrHoleName = itemAdd.NameOrHoleName;


                var newSam = new CVisualSampleArea();
                newSam.SetSampleGDIObject(sample);
                newSam.SetSampleName(sample.SampleName);
                m_visualSamples.Add(newSam);
                outsample = newSam;
                return true;
            }
            outsample = null;

            return false;
        }
        #region 设置工作样品
        /// <summary>
        /// 设置工作样品与测量区域
        /// </summary>
        /// <param name="sampleName">样品名称</param>
        public void SetSampleOrder(string sampleName)
        {


            //修改测量区域集合 索引     (添加样品或者切换样品时，将当前工作样品显示在样品孔的最上)
            m_visualSamples = SelectMeasureIndexIsTop(m_visualSamples, sampleName);


        }
        #endregion
        private List<CVisualSampleArea> SelectMeasureIndexIsTop(List<CVisualSampleArea> objList, string SampleName)
        {
            List<CVisualSampleArea> objListTemp = objList;
            CVisualSampleArea itemTemp;
            foreach (CVisualSampleArea item in objList)
            {
                if (item.GetSampleName() == SampleName)
                {
                    //临时记录所选测量区域
                    itemTemp = item;
                    //删除原信息
                    objListTemp.Remove(item);
                    //添加新信息
                    objListTemp.Insert(objListTemp.Count, itemTemp);
                    break;
                }
            }
            return objListTemp;
        }


        //响应委托事件的样品台数据
        public void InitStageDisplay(CStage SStage, CSEMStageData SEMStageData)
        {
            m_visualStage.InitSampleStageData(SStage, SEMStageData, this.Width, this.Height);


            //清除所有绘制的图形信息
            ClearDrawInfo();
            //绘制样品台信息
            m_visualStage.DrawSampleStage();


            //标尺初始化
            RulerInit(m_visualStage.GetOTSSampleStageData());

            ShowRulerLocation();



            if (m_visualSamples.Count == 0)
            {
                //将测量状态初始化
                m_MeasureAppForm.m_MessureStatuWindow.SetMeasureStatusInit();
            }


            Invalidate();
        }



        private void GetTriangleExcenterRadius(PointF px1, PointF px2, PointF px3, out float R, out PointF center)
        {
            float x1, y1, x2, y2, x3, y3;
            float a, b;
            x1 = px1.X;
            y1 = px1.Y;
            x2 = px2.X;
            y2 = px2.Y;
            x3 = px3.X;
            y3 = px3.Y;
            a = ((y2 - y1) * (y3 * y3 - y1 * y1 + x3 * x3 - x1 * x1) - (y3 - y1) * (y2 * y2 - y1 * y1 + x2 * x2 - x1 * x1)) / (2 * ((x3 - x1) * (y2 - y1) - (x2 - x1) * (y3 - y1)));
            b = ((x2 - x1) * (x3 * x3 - x1 * x1 + y3 * y3 - y1 * y1) - (x3 - x1) * (x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1)) / (2 * ((y3 - y1) * (x2 - x1) - (y2 - y1) * (x3 - x1)));
            center = new PointF(a, b);
            R = (float)Math.Sqrt((x1 - a) * (x1 - a) + (y1 - b) * (y1 - b));
        }


        #region 窗体事件
        private void OTSSamplespaceWindow_Load(object sender, EventArgs e)
        {

            m_visualStage = new CVisualStage();

            m_visualSamples = new List<CVisualSampleArea>();


            this.ResizeRedraw = true;
            control_Ruler2 = new Control_Ruler();
            Point rulerLocation = new Point(10, this.Height - (int)(control_Ruler2.Height * 2));
            control_Ruler2.Location = rulerLocation;
            this.Controls.Add(control_Ruler2);
            log = NLog.LogManager.GetCurrentClassLogger();

            pictureBox1.BackColor = Color.Transparent;

            sampleHoleImageBuffer = new CDisplayGDIObject(new RectangleF(0, 0, this.Width, this.Height), GDIType.SampleHoleImageBuffer); ;
            sampleHoleImageBuffer.BSEImage = new Bitmap(this.Width, this.Height);


        }



        public static void SetShowCMStrip(ContextMenuType menuType, ContextMenuStrip cmStrip)
        {

            switch (menuType)
            {
                case ContextMenuType.SampleHoleMenu:
                    cmStrip.Items[(int)MenuIndex.AddSample].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteSample].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.ReadSEMData].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.SetSemData].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.SetSEMCenterLocation].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCenterLocation].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCurrentLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.SEMStripSeparator].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.ShootBSEPicture].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DeleteBSEPicture].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DeleteSampleData].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.SlopFocus].Enabled = false;
                    break;
                case ContextMenuType.SampleMenu:
                    cmStrip.Items[(int)MenuIndex.AddSample].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteSample].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.ReadSEMData].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.SetSemData].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.SetSEMCenterLocation].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCenterLocation].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCurrentLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.SEMStripSeparator].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.ShootBSEPicture].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteBSEPicture].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DeleteSampleData].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.SlopFocus].Enabled = true;
                    break;
                case ContextMenuType.MeasureMenu:
                    cmStrip.Items[(int)MenuIndex.AddSample].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteSample].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.ReadSEMData].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.SetSemData].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.SetSEMCenterLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCenterLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCurrentLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.ShootBSEPicture].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteBSEPicture].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteSampleData].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.SlopFocus].Enabled = true;


                    break;
                case ContextMenuType.FieldMenu:
                    cmStrip.Items[(int)MenuIndex.AddSample].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteSample].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.ReadSEMData].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.SetSemData].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.SetSEMCenterLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCenterLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCurrentLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.ShootBSEPicture].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteBSEPicture].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteSampleData].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.SlopFocus].Enabled = true;


                    break;
                case ContextMenuType.ThreadRunMenu:
                    for (int i = 0; i < cmStrip.Items.Count; i++)
                    {
                        cmStrip.Items[i].Enabled = false;
                    }
                    break;
                case ContextMenuType.SampleStateMenu:
                    cmStrip.Items[(int)MenuIndex.AddSample].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DeleteSample].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.ReadSEMData].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.SetSemData].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.SetSEMCenterLocation].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCenterLocation].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCurrentLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.ShootBSEPicture].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DeleteBSEPicture].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DeleteSampleData].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.SlopFocus].Enabled = false;
                    break;
                case ContextMenuType.SampleHoleBSEImage:
                    cmStrip.Items[(int)MenuIndex.AddSample].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteSample].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.ReadSEMData].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.SetSemData].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.SetSEMCenterLocation].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCenterLocation].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCurrentLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.ShootBSEPicture].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteBSEPicture].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteSampleData].Enabled = false;
                    cmStrip.Items[(int)MenuIndex.SlopFocus].Enabled = false;
                    break;
            }
        }
        private List<CDisplayGDIObject> GetAllVisualSampleGDIObject()
        {
            List<CDisplayGDIObject> allobj = new List<CDisplayGDIObject>();
            foreach (var s in m_visualSamples)
            {
                allobj.Add(s.GetSampleGDIObject());
                allobj.Add(s.GetMeasureGDIObject());

                //foreach (var f in s.GetMeasureFieldGDIObjects())
                //{
                //    allobj.Add(f);

                //}


            }
            allobj.AddRange(m_visualStage.FrameOfHoleGDIObjects);
            allobj.Add(sampleHoleImageBuffer);


            return allobj;


        }
        private List<CDisplayGDIObject> GetOnlyVisualSampleGDIObject()
        {
            List<CDisplayGDIObject> allobj = new List<CDisplayGDIObject>();
            foreach (var s in m_visualSamples)
            {
                allobj.Add(s.GetSampleGDIObject());

            }


            return allobj;


        }
        private List<CDisplayGDIObject> GetAllVisualFieldGdiObject()
        {
            List<CDisplayGDIObject> allobj = new List<CDisplayGDIObject>();
            foreach (var s in m_visualSamples)
            {
                allobj.Add(s.GetMeasureGDIObject());
                //var flds = s.GetMeasureFieldGDIObjects();
                //for (int i = flds.Count; i > 0; i--)//revert the sequence so that the last field will paint first.then the green or yellow rectangle can display fully.
                //{
                //    var f = flds[i - 1];
                //    allobj.Add(f);

                //}


            }


            return allobj;


        }
        private EnumMousePointPosition MousePointPosition(Point point, Point e)
        {
            //MouseDrag 中心
            if ((e.X == point.X) && (e.Y == point.Y))
            {
                return EnumMousePointPosition.MouseDrag;
            }
            //MouseSizeTopLeft 上左
            if ((e.X < point.X) && (e.Y < point.Y))
            {
                return EnumMousePointPosition.MouseSizeTopLeft;
            }
            //MouseSizeTopRight 下右
            if ((e.X > point.X) && (e.Y < point.Y))
            {
                return EnumMousePointPosition.MouseSizeTopRight;
            }
            //MouseSizeLeft 左侧
            if ((e.X < point.X) && (e.Y == point.Y))
            {
                return EnumMousePointPosition.MouseSizeLeft;
            }
            //MouseSizeRight 右侧
            if ((e.X > point.X) && (e.Y == point.Y))
            {
                return EnumMousePointPosition.MouseSizeRight;
            }
            //MouseSizeTop 上侧
            if ((e.X == point.X) && (e.Y < point.Y))
            {
                return EnumMousePointPosition.MouseSizeTop;
            }
            //MouseSizeBottom 下侧
            if ((e.X == point.X) && (e.Y > point.Y))
            {
                return EnumMousePointPosition.MouseSizeBottom;
            }
            //MouseSizeBottomRight 下左
            if ((e.X < point.X) && (e.Y > point.Y))
            {
                return EnumMousePointPosition.MouseSizeBottomLeft;
            }
            //MouseSizeBottomRight 下右
            if ((e.X > point.X) && (e.Y > point.Y))
            {
                return EnumMousePointPosition.MouseSizeBottomRight;
            }
            return EnumMousePointPosition.MouseSizeNone;
        }
        List<PointF> m_ThreePointCirclePoints = new List<PointF>();
        protected override void OnMouseDown(MouseEventArgs e)
        {
            //lblFocus.Focus();
            bool runflag = m_MeasureAppForm.MeasureThreadRunFlag;


            Point _Point;
            this.m_MouseDownPoint = new Point(e.X, e.Y);
            //判断当前是否手绘
            if (m_IsDrawMeasure && !runflag)
            {
                var measurepoint = new Rectangle(this.m_MouseDownPoint, new Size(2, 2));
                if (m_visualStage.CheckMeasureAreaIsBeyondStageArea(measurepoint))
                {
                    m_IsDrawMeasure = true;
                }
                else
                {
                    m_IsDrawMeasure = false;
                    return;
                }

                COTSSample workSample = m_MeasureAppForm.m_ProjParam.GetWorkSample();
                if (workSample == null) return;
                string sampleHoleName = workSample.GetSampleHoleName();
                string sampleName = workSample.GetName();


                //绘制多边形 测量区域
                if (m_DrawMeasureType == DrawMeasureAreaActionType.Polygon)
                {
                    if (m_DrawMeasureGDIObject == null)
                    {
                        m_DrawMeasureGDIObject = new CMeasureArea(new List<PointF>(), ShapeType.POLYGON, sampleHoleName, sampleName, Color.Red);

                    }

                    var polygonPoints = m_DrawMeasureGDIObject.GetPolygonPointFList();


                    if (m_IsDrawPolygonFinish)
                    {
                        DialogResult dResult = MessageBox.Show(table["message10"].ToString(), table["message11"].ToString(), MessageBoxButtons.YesNo);
                        if (dResult == DialogResult.Yes)
                        {
                            Point startPoint = new Point((int)(polygonPoints[0].X), (int)(polygonPoints[0].Y));//the last point is the first point too.we get the first point as the last point.
                            polygonPoints.Add(startPoint);
                            CMeasureArea polygonGdi = new CMeasureArea(polygonPoints, ShapeType.POLYGON, sampleHoleName, sampleName, Color.Red);


                            polygonGdi.SetZoomNumber(m_visualStage.GetZoomNum());
                            polygonGdi.SetDisplayRefPoint(m_visualStage.GetDisplayRefPoint());
                            polygonGdi.SetPolygonPointFList(polygonPoints);

                            polygonGdi.IsWorkSample = true;


                            var sam = GetVisualSampleByName(sampleName);
                            if (sam == null) return;
                            sam.SetMeasureGDIObject(polygonGdi);


                            m_DrawPolygonFinishGDIObject = null;
                            m_DrawMeasureGDIObject = null;

                            var para = m_visualStage.GetSampleMeasurePara(sam.GetMeasureGDIObject());

                            m_MeasureAppForm.m_ProjParam.SetWorkSampleHoleAndMeasureArea(para);

                            m_MeasureAppForm.SwitchWSample(m_SampleSelectName);

                            //-------------------- draw measrue field and save these data to sample

                            PrepareMeasureField(sam, MSR_RUN_TYPE.RUNMEASURE);
                            //--------------------

                            Invalidate();



                            m_IsDrawMeasure = false;
                            m_IsDrawPolygonFinish = false;
                            this.Cursor = Cursors.Default;
                            return;
                        }
                        else
                        {
                            return;
                        }
                    }


                    polygonPoints.Add(m_MouseDownPoint);


                    m_DrawMeasureGDIObject.SetPolygonPointFList(polygonPoints);

                    return;
                }
                else if (m_DrawMeasureType == DrawMeasureAreaActionType.CircleByThreePoints)
                {
                    if (m_DrawMeasureGDIObject == null)
                    {
                        m_DrawMeasureGDIObject = new CMeasureArea(new List<PointF>(), ShapeType.POLYGON, sampleHoleName, sampleName, Color.Red);

                    }
                    var m_ThreePointCirclePoints = m_DrawMeasureGDIObject.GetPolygonPointFList();

                    m_ThreePointCirclePoints.Add(m_MouseDownPoint);




                    if (m_ThreePointCirclePoints.Count == 3)//three point can make a circle .
                    {


                        float r;
                        PointF Centerpoint;
                        GetTriangleExcenterRadius(m_ThreePointCirclePoints[0], m_ThreePointCirclePoints[1], m_ThreePointCirclePoints[2], out r, out Centerpoint);

                        RectangleF rectangleThree = new RectangleF(new PointF(Centerpoint.X - r, Centerpoint.Y - r), new SizeF(r * 2, r * 2));


                        if (m_visualStage.CheckMeasureAreaIsBeyondStageArea(rectangleThree))
                        {
                            m_IsDrawMeasure = true;
                        }
                        else
                        {
                            m_IsDrawMeasure = false;
                            return;
                        }
                        Color MeasureColor = Color.Red;
                        CMeasureArea CRectangleGDI = new CMeasureArea(rectangleThree, ShapeType.CIRCLE, sampleHoleName, sampleName, MeasureColor);


                        m_DrawMeasureGDIObject = CRectangleGDI;
                        m_DrawMeasureGDIObject.SetZoomNumber(m_visualStage.GetZoomNum());
                        m_DrawMeasureGDIObject.SetDisplayRefPoint(m_visualStage.GetDisplayRefPoint());


                        var sam1 = GetVisualSampleByName(sampleName);
                        if (sam1 == null) return;
                        sam1.SetMeasureGDIObject(m_DrawMeasureGDIObject);
                        sam1.GetMeasureGDIObject().SetZoomedRegionF(rectangleThree);
                        m_DrawMeasureGDIObject = null;
                        m_ThreePointCirclePoints.Clear();
                        var para = m_visualStage.GetSampleMeasurePara(sam1.GetMeasureGDIObject());
                        m_MeasureAppForm.m_ProjParam.SetWorkSampleHoleAndMeasureArea(para);

                        m_MeasureAppForm.SetRunType(MSR_RUN_TYPE.RUNMEASURE);

                        m_MeasureAppForm.SwitchWSample(m_SampleSelectName);
                        Invalidate();
                        //设置手绘标识
                        m_IsDrawMeasure = false;
                        this.Cursor = Cursors.Default;
                        return;

                    }
                    Invalidate();
                    return;
                }
                else if (m_DrawMeasureType == DrawMeasureAreaActionType.Rectangle)
                {



                    int sizeWH = 5;
                    Size size = new Size(sizeWH, sizeWH);
                    Rectangle rectangle = new Rectangle(m_MouseDownPoint, size);
                    Color MeasureColor = Color.Red;
                    CMeasureArea newGDI;

                    newGDI = new CMeasureArea(rectangle, ShapeType.RECTANGLE, sampleName, sampleName, MeasureColor);

                    newGDI.SetZoomNumber(m_visualStage.GetZoomNum());
                    newGDI.SetDisplayRefPoint(m_visualStage.GetDisplayRefPoint());

                    m_DrawMeasureGDIObject = newGDI;


                    return;
                }
                else if (m_DrawMeasureType == DrawMeasureAreaActionType.Circle)
                {



                    int sizeWH = 5;
                    Size size = new Size(sizeWH, sizeWH);
                    Rectangle rectangle = new Rectangle(m_MouseDownPoint, size);
                    Color MeasureColor = Color.Red;
                    CMeasureArea newGDI;

                    newGDI = new CMeasureArea(rectangle, ShapeType.CIRCLE, sampleName, sampleName, MeasureColor);

                    newGDI.SetZoomNumber(m_visualStage.GetZoomNum());
                    newGDI.SetDisplayRefPoint(m_visualStage.GetDisplayRefPoint());

                    m_DrawMeasureGDIObject = newGDI;


                    return;
                }
                else if (m_DrawMeasureType == DrawMeasureAreaActionType.InverseSelection)
                {



                    int sizeWH = 5;
                    Size size = new Size(sizeWH, sizeWH);
                    Rectangle rectangle = new Rectangle(m_MouseDownPoint, size);
                    Color MeasureColor = Color.Red;
                    CMeasureArea newGDI;

                    newGDI = new CMeasureArea(rectangle, ShapeType.RECTANGLE, sampleName, sampleName, MeasureColor);

                    newGDI.SetZoomNumber(m_visualStage.GetZoomNum());
                    newGDI.SetDisplayRefPoint(m_visualStage.GetDisplayRefPoint());

                    m_DrawMeasureGDIObject = newGDI;


                    return;
                }
            }
            else if (!m_IsDrawMeasure)
            {
                if (e.Button == MouseButtons.Right)
                {
                    if (m_MeasureAppForm.MeasureThreadRunFlag)
                    {


                        SetShowCMStrip(ContextMenuType.ThreadRunMenu, CMStrip);

                        _Point = this.PointToClient(Cursor.Position);
                        this.CMStrip.Show(this, _Point);
                        return;
                    }
                    //获取鼠标右键点击位置
                    m_MouseDownPoint = e.Location;



                    var workingSam = GetWorkingVisualSample();
                    if (workingSam != null)
                    {
                        foreach (CDisplayGDIObject item in workingSam.GetMeasureFieldGDIObjects())
                        {
                            if (item.IfZoomContains(e.Location))
                            {


                                _Point = this.PointToClient(Cursor.Position);


                                SetShowCMStrip(ContextMenuType.FieldMenu, CMStrip);
                                this.CMStrip.Show(this, _Point);
                                return;
                            }
                        }

                    }



                    foreach (var item in m_visualSamples)
                    {
                        bool isSelectingMeasureArea = false;
                        if (item.GetMeasureGDIObject().Myshape == ShapeType.POLYGON)
                        {

                            if (item.GetMeasureGDIObject().GetGPath().IsVisible(e.Location))
                            {
                                isSelectingMeasureArea = true;
                            }
                        }
                        else
                        {
                            if (item.GetMeasureGDIObject().IfZoomContains(e.Location))
                            {
                                isSelectingMeasureArea = true;
                                int WH = 2;
                                Rectangle rect = new Rectangle(e.Location, new Size(WH, WH));

                                if (!m_visualStage.CheckMeasureAreaIsBeyondStageArea(rect))
                                {
                                    break;
                                }
                            }
                        }
                        if (isSelectingMeasureArea)
                        {

                            SetShowCMStrip(ContextMenuType.MeasureMenu, CMStrip);
                            _Point = this.PointToClient(Cursor.Position);
                            this.CMStrip.Show(this, _Point);


                            m_SampleHoleSelectName = item.GetMeasureGDIObject().NameOrHoleName;
                            if (m_SampleSelectName != item.GetMeasureGDIObject().SampleName)
                            {
                                m_SampleSelectName = item.GetSampleName();

                                item.SetIsWorkSample(true);
                                //设置工作样品
                                m_MeasureAppForm.SwitchWSample(m_SampleSelectName);
                                Invalidate();
                            }
                            return;
                        }
                    }

                    foreach (CDisplayGDIObject item in m_visualStage.FrameOfHoleGDIObjects)
                    {
                        if (item.IfZoomContains(e.Location))
                        {


                            _Point = this.PointToClient(Cursor.Position);

                            SetShowCMStrip(ContextMenuType.SampleHoleBSEImage, CMStrip);
                            this.CMStrip.Show(this, _Point);
                            return;
                        }
                    }



                    //只点击样品上(测量区域被移动到其他地方)
                    for (int i = m_visualSamples.Count - 1; i >= 0; i--)
                    {
                        if (m_visualSamples[i].GetSampleGDIObject().IfZoomContains(e.Location))
                        {


                            _Point = this.PointToClient(Cursor.Position);

                            //设置编辑右键菜单项
                            SetShowCMStrip(ContextMenuType.SampleMenu, CMStrip);
                            this.CMStrip.Show(this, _Point);

                            if (m_SampleSelectName != m_visualSamples[i].GetSampleName())
                            {
                                m_SampleSelectName = m_visualSamples[i].GetSampleName();
                                m_SampleHoleSelectName = m_visualSamples[i].GetMeasureGDIObject().NameOrHoleName;

                                m_visualSamples[i].SetIsWorkSample(true);

                                m_MeasureAppForm.SwitchWSample(m_SampleSelectName);
                                Invalidate();
                            }
                            return;
                        }
                    }
                    //点击样品孔

                    CDisplayGDIObject gdiitem;
                    if (m_visualStage.IfMouseInSampleHole(e.Location, out gdiitem))
                    {

                        _Point = this.PointToClient(Cursor.Position);

                        SetShowCMStrip(ContextMenuType.SampleHoleMenu, CMStrip);

                        this.CMStrip.Show(this, _Point);

                        m_SampleHoleSelectName = gdiitem.NameOrHoleName;

                        return;
                    }


                    if (m_visualStage.IfMouseInStage(e.Location))
                    {


                        SetShowCMStrip(ContextMenuType.SampleStateMenu, CMStrip);
                        _Point = this.PointToClient(Cursor.Position);
                        this.CMStrip.Show(this, _Point);
                        return;
                    }


                    return;
                }
                else if (e.Button == MouseButtons.Left)
                {


                    //测量区域
                    if (Control.ModifierKeys == Keys.Control)// ctrl key is pressed,means changing position or altering the visual sample area.
                    {
                        var sam = GetWorkingVisualSample();
                        if (sam != null)
                        {
                            var item = sam.GetMeasureGDIObject();

                            var selWSampleMeasureStatus = m_MeasureAppForm.m_ProjParam.GetWorkSampleMeasureStatus();
                            if (selWSampleMeasureStatus)
                            {
                                return;
                            }

                            if (item.Myshape == ShapeType.POLYGON)
                            {

                                bool isSelPolygonPoint = false;
                                foreach (PointF itemPoint in item.GetPolygonPointFList())
                                {
                                    if (Math.Abs(itemPoint.X - e.X) <= m_OffsetPX && Math.Abs(itemPoint.Y - e.Y) <= m_OffsetPX)
                                    {

                                        isSelPolygonPoint = true;

                                        item.SelColor = Color.Red;

                                        item.DraggingPoint = new PointF(itemPoint.X, itemPoint.Y);//e.Location;
                                        item.IsAltering = true;//this state means operator want to alter the size of the polygon shape.

                                        item.IsDragging = false;

                                        break;

                                    }
                                }

                                if (!isSelPolygonPoint)//not selecting the polygon point,just dragging on the inside area of the polygon shape.
                                {

                                    if (item.GetGPath().IsVisible(e.Location))
                                    {

                                        item.SelColor = Color.Red;
                                        item.IsDragging = true;
                                        item.DraggingPoint = e.Location;

                                        item.IsAltering = false;

                                    }



                                }



                            }
                            else
                            {

                                if (item.GetGPath().IsOutlineVisible((float)e.X, (float)e.Y, new Pen(Color.Gray, m_PenWidth)))
                                {

                                    item.SelColor = Color.Red;
                                    item.IsDragging = false;
                                    item.DraggingPoint = e.Location;
                                    item.IsAltering = true;


                                }
                                else//not outlinevisible then is altering sample area position.
                                {
                                    if (item.IfZoomContains(e.Location))
                                    {

                                        item.SelColor = Color.Red;
                                        item.IsDragging = true;
                                        item.DraggingPoint = e.Location;
                                        item.IsAltering = false;

                                    }

                                }

                            }

                        }
                    }

                    //click on the sample area without ctrl key,just switch to that sample.
                    if (!(Control.ModifierKeys == Keys.Control) && !runflag)
                    {
                        for (int i = m_visualSamples.Count - 1; i >= 0; i--)
                        {
                            var sam1 = m_visualSamples[i];


                            if (sam1.GetSampleGDIObject().IfZoomContains(e.Location) || sam1.GetMeasureGDIObject().IfZoomContains(e.Location))
                            {
                                //NLog.LogManager.GetCurrentClassLogger().Info(sam1.GetMeasureGDIObject().GetOrigionalDrawRegionF().ToString());
                                var measureItem = sam1.GetMeasureGDIObject();


                                measureItem.SelColor = Color.Red;


                                //设置为工作样品
                                sam1.SetIsWorkSample(true);

                                //获取颜色
                                var theColor = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleSelColor);
                                sam1.GetSampleGDIObject().SelColor = theColor;


                                m_SampleSelectName = sam1.GetSampleName();
                                m_MeasureAppForm.SwitchWSample(m_SampleSelectName);

                                break;
                            }
                        }

                    }

                    CDisplayGDIObject stageobj;
                    if (m_visualStage.IfMouseInStage(e.Location, out stageobj))
                    {

                        MouseDownFunction(m_visualStage.GetAllGDIObject(), e);
                        //样品
                        MouseDownFunction(GetAllVisualSampleGDIObject(), e);





                    }


                }
            }
            //重绘控件
            Invalidate();
        }



        protected override void OnMouseMove(MouseEventArgs e)
        {


            bool runflag = m_MeasureAppForm.MeasureThreadRunFlag;

            if (runflag)
            {
                return;
            }
            this.m_MouseMovePoint = new Point(e.X, e.Y);
            if (m_IsDrawMeasure && !runflag)
            {


                if (m_DrawMeasureGDIObject == null) return;//the object must be initialized by mousedown event.
                //绘制多边形
                if (m_DrawMeasureType == DrawMeasureAreaActionType.Polygon)
                {

                    m_DrawMeasureGDIObject.PolygonDrawingEndPoint = this.m_MouseMovePoint;
                    var m_PolygonPoint = m_DrawMeasureGDIObject.GetPolygonPointFList();

                    //显示直线开始点与鼠标当前位置的直线
                    PointF startPoint = new PointF();
                    if (m_PolygonPoint.Count > 0)
                    {
                        startPoint = m_PolygonPoint[0];

                    }
                    //显示绘制多边形完成标识
                    if (m_PolygonPoint.Count > m_PolygonMinPointCount)
                    {
                        if (Math.Abs(m_MouseMovePoint.X - startPoint.X) <= m_OffsetPX && Math.Abs(m_MouseMovePoint.Y - startPoint.Y) <= m_OffsetPX)
                        {
                            //显示绘制多边形完成标识
                            m_IsDrawPolygonFinish = true;
                            int rectSize = m_MinMeasureWidthValue;

                            if (m_DrawPolygonFinishGDIObject == null)
                            {
                                Point PolygonFinishPoint = new Point((int)(startPoint.X - m_MinMeasureWidthValue / 2), (int)(startPoint.Y - m_MinMeasureWidthValue / 2));
                                Rectangle pRect = new Rectangle(PolygonFinishPoint, new Size(rectSize, rectSize));
                                CDisplayGDIObject createPolygonFinish = new CDisplayGDIObject(pRect, GDIType.DrawPolygonFinish, "", "", Color.Green);
                                m_DrawPolygonFinishGDIObject = createPolygonFinish;

                            }
                        }
                        else
                        {
                            m_DrawPolygonFinishGDIObject = null;
                            m_IsDrawPolygonFinish = false;
                        }
                    }

                }
                //圆形三点法
                else if (m_DrawMeasureType == DrawMeasureAreaActionType.CircleByThreePoints)
                {
                    //m_ThreePointCirclePoints[m_ThreePointCirclePoints.Count-1] = this.m_MouseMovePoint;
                    m_DrawMeasureGDIObject.PolygonDrawingEndPoint = this.m_MouseMovePoint;
                }
                else
                {
                    if (m_DrawMeasureGDIObject == null)
                    {
                        return;
                    }



                    RectangleF rectangle = m_DrawMeasureGDIObject.GetZoomedRegion;
                    int tmp = (int)Math.Sqrt((m_MouseDownPoint.X - m_MouseMovePoint.X) * (m_MouseDownPoint.X - m_MouseMovePoint.X) + (m_MouseDownPoint.Y - m_MouseMovePoint.Y) * (m_MouseDownPoint.Y - m_MouseMovePoint.Y));
                    if (tmp == 0)
                    {
                        tmp = m_DValue;
                    }

                    EnumMousePointPosition enumMouse = MousePointPosition(m_MouseDownPoint, m_MouseMovePoint);
                    Point LTPoint = new Point();
                    Size RBSize = new Size();
                    switch (enumMouse)
                    {
                        case EnumMousePointPosition.MouseSizeTopLeft:
                            if (m_DrawMeasureType == DrawMeasureAreaActionType.Circle)
                            {
                                LTPoint.X = m_MouseDownPoint.X - tmp;
                                LTPoint.Y = m_MouseDownPoint.Y - tmp;
                                RBSize.Width = tmp;
                                RBSize.Height = tmp;
                                rectangle = new Rectangle(LTPoint, RBSize);
                            }
                            else
                            {
                                LTPoint.X = m_MouseMovePoint.X;
                                LTPoint.Y = m_MouseMovePoint.Y;
                                RBSize.Width = m_MouseDownPoint.X - m_MouseMovePoint.X;
                                RBSize.Height = m_MouseDownPoint.Y - m_MouseMovePoint.Y;
                                rectangle = new Rectangle(LTPoint, RBSize);
                            }
                            break;
                        case EnumMousePointPosition.MouseSizeTopRight:
                            if (m_DrawMeasureType == DrawMeasureAreaActionType.Circle)
                            {
                                LTPoint.X = m_MouseDownPoint.X;
                                LTPoint.Y = m_MouseDownPoint.Y - tmp;
                                RBSize.Width = tmp;
                                RBSize.Height = tmp;
                                rectangle = new Rectangle(LTPoint, RBSize);
                            }
                            else
                            {
                                LTPoint.X = m_MouseDownPoint.X;
                                LTPoint.Y = m_MouseDownPoint.Y - (m_MouseDownPoint.Y - m_MouseMovePoint.Y);
                                RBSize.Width = m_MouseMovePoint.X - m_MouseDownPoint.X;
                                RBSize.Height = m_MouseDownPoint.Y - m_MouseMovePoint.Y;
                                rectangle = new Rectangle(LTPoint, RBSize);
                            }
                            break;
                        case EnumMousePointPosition.MouseSizeBottomLeft:
                            if (m_DrawMeasureType == DrawMeasureAreaActionType.Circle)
                            {
                                LTPoint.X = m_MouseDownPoint.X - tmp;
                                LTPoint.Y = m_MouseDownPoint.Y;
                                RBSize.Width = tmp;
                                RBSize.Height = tmp;
                                rectangle = new Rectangle(LTPoint, RBSize);
                            }
                            else
                            {
                                LTPoint.X = m_MouseDownPoint.X - (m_MouseDownPoint.X - m_MouseMovePoint.X);
                                LTPoint.Y = m_MouseDownPoint.Y;
                                RBSize.Width = m_MouseDownPoint.X - m_MouseMovePoint.X;
                                RBSize.Height = m_MouseMovePoint.Y - m_MouseDownPoint.Y;
                                rectangle = new Rectangle(LTPoint, RBSize);
                            }
                            break;
                        case EnumMousePointPosition.MouseSizeBottomRight:
                            if (m_DrawMeasureType == DrawMeasureAreaActionType.Circle)
                            {
                                LTPoint.X = m_MouseDownPoint.X;
                                LTPoint.Y = m_MouseDownPoint.Y;
                                RBSize.Width = tmp;
                                RBSize.Height = tmp;
                                rectangle = new Rectangle(LTPoint, RBSize);
                            }
                            else
                            {
                                LTPoint.X = m_MouseDownPoint.X;
                                LTPoint.Y = m_MouseDownPoint.Y;
                                RBSize.Width = m_MouseMovePoint.X - m_MouseDownPoint.X;
                                RBSize.Height = m_MouseMovePoint.Y - m_MouseDownPoint.Y;
                                rectangle = new Rectangle(LTPoint, RBSize);
                            }
                            break;
                    }
                    //在样品台内部缩放
                    if (m_visualStage.CheckMeasureAreaIsBeyondStageArea(rectangle))
                    {

                        var rec = new Rectangle(LTPoint, RBSize);
                        m_DrawMeasureGDIObject.SetZoomedRegionF(new RectangleF(new PointF((rec.X), (rec.Y)), new SizeF(rec.Width, rec.Height)));


                    }

                }
            }




            if ((Control.ModifierKeys == Keys.Control) && !runflag)//is dragging on the edge or on the vertex so we can alter the size of the item.
            {
                var sam = GetWorkingVisualSample();
                if (sam == null) return;
                var curMeasureGdi = sam.GetMeasureGDIObject();
                if (curMeasureGdi.IsAltering)//click on the  edge or on the polygon point(or vertex point of rectangle).
                {

                    if (curMeasureGdi.Myshape == ShapeType.POLYGON)
                    {


                        for (int i = 0; i < curMeasureGdi.GetPolygonPointFList().Count; i++)
                        {
                            if (curMeasureGdi.GetPolygonPointFList()[i].X == curMeasureGdi.DraggingPoint.X && curMeasureGdi.GetPolygonPointFList()[i].Y == curMeasureGdi.DraggingPoint.Y)
                            {
                                //移动点的位置
                                RectangleF selPolygonPointRect = new RectangleF(0, 0, 2, 2);
                                selPolygonPointRect.X = curMeasureGdi.DraggingPoint.X + e.X - curMeasureGdi.DraggingPoint.X;
                                selPolygonPointRect.Y = curMeasureGdi.DraggingPoint.Y + e.Y - curMeasureGdi.DraggingPoint.Y;
                                //判断样品是否超越样品台
                                if (m_visualStage.CheckMeasureAreaIsBeyondStageArea(selPolygonPointRect))
                                {
                                    List<PointF> polygonPs = curMeasureGdi.GetPolygonPointFList();
                                    if (i == 0 || i == curMeasureGdi.GetPolygonPointFList().Count - 1)
                                    {
                                        curMeasureGdi.DraggingPoint = new Point(e.X, e.Y);
                                        polygonPs[0] = curMeasureGdi.DraggingPoint;
                                        polygonPs[curMeasureGdi.GetPolygonPointFList().Count - 1] = curMeasureGdi.DraggingPoint;//the last point and the first point of one polygon object are the same.

                                    }
                                    else
                                    {
                                        curMeasureGdi.DraggingPoint = new Point(e.X, e.Y);

                                        polygonPs[i] = curMeasureGdi.DraggingPoint;


                                    }
                                    curMeasureGdi.SetPolygonPointFList(polygonPs);

                                    curMeasureGdi.DraggingPoint = e.Location;
                                    break;
                                }
                            }
                        }



                    }
                    else
                    {
                        if (curMeasureGdi.Myshape == ShapeType.RECTANGLE)
                        {
                            List<PointF> vertexPoint = curMeasureGdi.GetVertexPoints();
                            var oldRegion = curMeasureGdi.GetZoomedRegionF();
                            for (int i = 0; i < vertexPoint.Count; i++)
                            {
                                var itemPoint = vertexPoint[i];
                                PointF lefttop, leftBottom, rightTop, rightBottom;
                                float width;
                                float height;
                                if (Math.Abs(itemPoint.X - e.X) <= m_OffsetPX && Math.Abs(itemPoint.Y - e.Y) <= m_OffsetPX)
                                {
                                    switch (i)
                                    {
                                        case 0://left top point
                                            lefttop = new PointF(e.X, e.Y);
                                            width = vertexPoint[2].X - e.X;
                                            height = vertexPoint[1].Y - e.Y;
                                            curMeasureGdi.SetZoomedRegionF(new RectangleF(lefttop, new SizeF(width, height)));

                                            break;
                                        case 1://left bottom
                                            leftBottom = new PointF(e.X, e.Y);
                                            width = vertexPoint[3].X - e.X;
                                            height = -(vertexPoint[0].Y - e.Y);
                                            curMeasureGdi.SetZoomedRegionF(new RectangleF(new PointF(leftBottom.X, leftBottom.Y - height), new SizeF(width, height)));
                                            break;

                                        case 2://right top 
                                            rightTop = new PointF(e.X, e.Y);
                                            width = -(vertexPoint[0].X - e.X);
                                            height = (vertexPoint[3].Y - e.Y);
                                            curMeasureGdi.SetZoomedRegionF(new RectangleF(new PointF(rightTop.X - width, rightTop.Y), new SizeF(width, height)));
                                            break;
                                        case 3://right bottom
                                            rightBottom = new PointF(e.X, e.Y);
                                            width = (e.X - vertexPoint[0].X);
                                            height = (e.Y - vertexPoint[0].Y);
                                            curMeasureGdi.SetZoomedRegionF(new RectangleF(new PointF(rightBottom.X - width, rightBottom.Y - height), new SizeF(width, height)));
                                            break;

                                    }

                                    Invalidate();
                                }
                            }


                        }
                        else
                        {

                            PointF gdicenter = m_visualStage.GetCenterPoint(curMeasureGdi.GetZoomedRegion);
                            //获取鼠标坐标
                            PointF mousePoint = e.Location;
                            RectangleF rectTemp;
                            //计算偏离半径
                            float a = (gdicenter.X - mousePoint.X) * (gdicenter.X - mousePoint.X);
                            float b = (gdicenter.Y - mousePoint.Y) * (gdicenter.Y - mousePoint.Y);
                            float c = a + b;
                            double r = System.Math.Sqrt(c);
                            float width = (float)r * 2;
                            rectTemp = new RectangleF(gdicenter.X - (float)r, gdicenter.Y - (float)r, width, width);


                            if (m_visualStage.CheckMeasureAreaIsBeyondStageArea(rectTemp))
                            {
                                //如果大于最小测量高度 设置图形大小
                                if (rectTemp.Width / curMeasureGdi.GetZoomNumber() > m_MinMeasureWidthValue)
                                {

                                    curMeasureGdi.SetZoomedRegionF(rectTemp);
                                    curMeasureGdi.DraggingPoint = e.Location;

                                }

                            }
                            else
                            {
                                return;
                            }
                            Invalidate();
                            return;

                        }

                    }


                }
                else if (curMeasureGdi.IsDragging)
                {
                    if (curMeasureGdi.GetGPath().IsVisible(e.Location))
                    {
                        if (m_visualStage.GetEdgeGDIObj().GetGPath().IsVisible(e.Location))
                        {

                            curMeasureGdi.PositionAltering(e.Location, true);

                        }

                    }

                }

            }
            else
            {


                //样品台
                MouseMoveFucntion(m_visualStage.GetAllGDIObject(), e);

                //样品
                MouseMoveFucntion(GetAllVisualSampleGDIObject(), e);

                //样品孔BSE图片
                MouseMoveFucntion(m_visualStage.FrameOfHoleGDIObjects, e);





            }


            //显示XY轴
            m_visualStage.ShowSemCoordvAL(e.Location, m_MeasureAppForm);
            Invalidate();

        }

        protected override void OnMouseUp(MouseEventArgs e)
        {
            //如果正在进行测量线程，则退出鼠标点击操作
            var runflag = m_MeasureAppForm.MeasureThreadRunFlag;


            var sam = GetWorkingVisualSample();

            //判断当前是否手绘

            if (m_IsDrawMeasure && !runflag)
            {


                 if (m_DrawMeasureType == DrawMeasureAreaActionType.InverseSelection)
                    {
                    var workspl = m_MeasureAppForm.m_ProjParam.GetWorkSample();
                        foreach (var gdi in sam.GetMeasureFieldGDIObjects())
                        {
                            if (m_DrawMeasureGDIObject.IfContains(new Point((int)gdi.GetCenterPoint().X, (int)gdi.GetCenterPoint().Y)))
                            {
                               gdi.Enable=!gdi.Enable;
                               
                              workspl.SetFieldEnable(new Point(gdi.OTSX,gdi.OTSY),gdi.Enable);
                            }

                        
                        }
                    
                        
                   m_DrawMeasureGDIObject = null;

                        this.Cursor = Cursors.Default;
                        //设置手绘标识

                        m_IsDrawMeasure = false;

                    }
                    else if(m_DrawMeasureType == DrawMeasureAreaActionType.Rectangle || m_DrawMeasureType == DrawMeasureAreaActionType.Circle)
                    {
                        var item = m_DrawMeasureGDIObject;


                        item.NameOrHoleName = sam.GetMeasureGDIObject().NameOrHoleName;

                        item.IsWorkSample = sam.GetMeasureGDIObject().IsWorkSample;

                        sam.GetMeasureFieldGDIObjects().Clear();
                        sam.SetMeasureGDIObject(item);

                        var para = m_visualStage.GetSampleMeasurePara(item);

                        m_MeasureAppForm.m_ProjParam.SetWorkSampleHoleAndMeasureArea(para);


                        m_MeasureAppForm.SetRunType(MSR_RUN_TYPE.RUNMEASURE);

                        PrepareMeasureField(sam, MSR_RUN_TYPE.RUNMEASURE);


                        m_DrawMeasureGDIObject = null;

                        this.Cursor = Cursors.Default;
                        //设置手绘标识

                        m_IsDrawMeasure = false;


                    }
                    
               

            }



            if (sam != null && !runflag)
            {

                var measureItem = sam.GetMeasureGDIObject();
                if (measureItem.IsDragging || measureItem.IsAltering)//while pressing ctrl key then it must be altering something(position or size)
                {
                    var selWSampleMeasureStatus = m_MeasureAppForm.m_ProjParam.GetWorkSampleMeasureStatus();
                    if (!selWSampleMeasureStatus)
                    {

                        var para = m_visualStage.GetSampleMeasurePara(measureItem);
                        m_MeasureAppForm.m_ProjParam.SetWorkSampleHoleAndMeasureArea(para);//set the altering result to the public parameter object


                        this.Cursor = System.Windows.Forms.Cursors.Default;

                        PrepareMeasureField(sam, m_MeasureAppForm.GetRunType());


                    }

                    measureItem.IsAltering = false;
                    measureItem.IsDragging = false;
                    Invalidate();

                }
            }
            //only moving the whole stage
            MouseUpFucntion(m_visualStage.GetAllGDIObject(), e);
            //样品 
            MouseUpFucntion(GetAllVisualSampleGDIObject(), e);




        }
        public void DrawSampleHoleImage(CDisplayGDIObject img)
        {
            var m_RegionF = img.GetOrigionalDrawRegionF();
            PointF startPointF = new PointF(m_RegionF.Left, m_RegionF.Top);
            PointF endPointF = new PointF(m_RegionF.Right + 2, m_RegionF.Bottom + 2);
            //绘制样品孔中图像信息
            if (img.BSEImage != null)
            {
                Image thumbnail = img.BSEImage.GetThumbnailImage((int)m_RegionF.Width + 2, (int)m_RegionF.Height + 2, null, IntPtr.Zero);
                var g = Graphics.FromImage(sampleHoleImageBuffer.BSEImage);
                g.DrawImage(thumbnail, startPointF);
            }

        }
        protected override void OnPaint(PaintEventArgs e)//处理重绘情况
        {

            OnPaint(e, m_visualStage.GetAllGDIObject());

            OnPaint(e, GetOnlyVisualSampleGDIObject());



            if (IsShowSampleHoleImage)
            {

                e.Graphics.DrawImage(sampleHoleImageBuffer.BSEImage, sampleHoleImageBuffer.GetZoomedRegionF());

            }





        }
        public void OnPaint(PaintEventArgs e, List<CDisplayGDIObject> m_ObjectGDIObjects)//处理重绘情况
        {
            foreach (CDisplayGDIObject item in m_ObjectGDIObjects.ToArray())
            {
                if (item != null)
                {
                    item.OnPaint(e);
                }
            }
        }


        protected override void OnMouseWheel(MouseEventArgs e)
        {
            bool runflag = m_MeasureAppForm.MeasureThreadRunFlag;
            if (runflag)
            {
                return;
            }
            var currentZoomNum = m_visualStage.GetZoomNum();
            //如果正在进行测量线程，则退出鼠标点击操作

            if (e.Delta > 0)
            {
                #region 计算标尺尺寸部份-----放大------
                //计算标尺实际占用像素的宽度
                f_ruler_size = f_old_ruler_size * currentZoomNum;
                control_Ruler2.RulerWidth = Convert.ToInt32(f_ruler_size);
                control_Ruler2.Value = 1;

                //放大过长时，这里将宽度与代表的实际宽度进行折半显示
                while (control_Ruler2.Width > 300)
                {
                    control_Ruler2.RulerWidth = Convert.ToInt32(control_Ruler2.RulerWidth) / 2;
                    control_Ruler2.Value = control_Ruler2.Value * 2;
                }
                control_Ruler2.SetValue(control_Ruler2.RulerWidth, control_Ruler2.Value.ToString());
                #endregion



            }
            else
            {

                if (currentZoomNum >= f_zoom_mix)
                {
                    #region 计算标尺尺寸部份-----缩小
                    f_ruler_size = f_old_ruler_size * currentZoomNum;
                    control_Ruler2.RulerWidth = Convert.ToInt32(f_ruler_size);
                    control_Ruler2.Value = 1;

                    while (control_Ruler2.Width > 300)
                    {
                        control_Ruler2.RulerWidth = Convert.ToInt32(control_Ruler2.RulerWidth) / 2;
                        control_Ruler2.Value = control_Ruler2.Value * 2;
                    }
                    control_Ruler2.SetValue(control_Ruler2.RulerWidth, control_Ruler2.Value.ToString());
                    #endregion
                }
            }


            //设置记录每次比例缩放后的总体比例系数
            if (e.Delta > 0)
            {
                currentZoomNum += 0.1f;


            }
            else
            {
                currentZoomNum -= 0.1f;
                if (currentZoomNum < 1)
                {
                    currentZoomNum = 1;
                }


                if (currentZoomNum == 1)
                {

                    //标尺恢复初始
                    f_ruler_size = f_old_ruler_size;

                    control_Ruler2.RulerWidth = Convert.ToInt32(f_ruler_size);
                    control_Ruler2.ShowString = "1mm";
                    control_Ruler2.SetValue(control_Ruler2.RulerWidth);
                }
            }



            MouseWheelFunction(GetAllVisualSampleGDIObject(), e.Location, currentZoomNum);
            //样品孔
            MouseWheelFunction(m_visualStage.GetAllGDIObject(), e.Location, currentZoomNum);



            base.OnMouseWheel(e);
            //重新绘制
            Invalidate();

        }

        private void MouseWheelFunction(List<CDisplayGDIObject> objList, Point mousePoint, float ZoomNum)
        {

            for (int i = 0; i < objList.Count; i++)
            {

                objList[i].Zoom(mousePoint, ZoomNum);
            }
        }
        #endregion

        #region 鼠标方法操作
        public void MouseDownFunction(List<CDisplayGDIObject> objList, MouseEventArgs e)
        {

            foreach (CDisplayGDIObject item in objList)
            {
                item.IsMoving = true;
                item.DraggingPoint = e.Location;
            }
        }
        public void MouseMoveFucntion(List<CDisplayGDIObject> objList, MouseEventArgs e)
        {
            foreach (CDisplayGDIObject item in objList)
            {
                if (item.IsMoving)
                {

                    item.Move(e.Location);

                }
            }
        }


        public void MouseUpFucntion(List<CDisplayGDIObject> objList, MouseEventArgs e)
        {
            foreach (CDisplayGDIObject item in objList)
            {
                if (item.IsDragging)
                {

                    item.IsDragging = false;
                    item.DraggingPoint = Point.Empty;

                }
                if (item.IsMoving)
                {

                    item.IsMoving = false;
                    item.DraggingPoint = Point.Empty;

                }
            }
        }


        #endregion


        private void DeleteSampleInfo(string sampleSelectName)
        {

            if (ShowDeleteDialog(sampleSelectName))
            {
                //设置当前状态
                m_MeasureAppForm.SetRunType(MSR_RUN_TYPE.RUNMEASURE);
                m_MeasureAppForm.DeleteSample(sampleSelectName);

            }
            return;

        }
        private bool ShowDeleteDialog(string sampleName)
        {
            //国际化
            OTSCommon.Language lan = new OTSCommon.Language();
            Hashtable table = lan.GetNameTable("OTSIncAMeasureAppForm");

            string str1 = table["message5"].ToString();
            string str2 = table["message6"].ToString();

            string sDeleteSampleName = str1;
            sDeleteSampleName += sampleName;
            sDeleteSampleName += "  信息 ?";
            if (DialogResult.OK == MessageBox.Show(sDeleteSampleName, "Delete sample information prompt", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        public bool setSlopFocusParam(_5_OTSMeasureStatuImageFun.SlopFocus slopFocus)
        {
            if (slopFocus == null)
            {
                return false;
            }
            else
            {
                m_MeasureAppForm.m_ProjParam.GetWorkSample().GetMsrParams().SlopParam = slopFocus.GetCSlopFocusParam();
                return true;
            }

        }

        protected override bool ProcessDialogKey(Keys keyData)
        {

            if (keyData == Keys.Up || keyData == Keys.Down || keyData == Keys.Left || keyData == Keys.Right)
            {
                return false;
            }
            else
            {
                return base.ProcessDialogKey(keyData);
            }
        }
        public void OTSSamplespaceWindow_KeyDown(object sender, KeyEventArgs e)
        {
            //鼠标相对于屏幕的坐标
            Point p1 = MousePosition;
            //鼠标相对于窗体的坐标
            Point mousePoint = this.PointToClient(p1);
            Pen GrayPen = new Pen(Color.Gray, m_PenWidth);


            //设置鼠标在样品测量区域上的样式
            foreach (var sam in m_visualSamples)
            {
                var item = sam.GetMeasureGDIObject();


                if (item.GetGPath() != null)
                {
                    if (item.Myshape == ShapeType.POLYGON)
                    {
                        //在多边形点附近切换光标
                        foreach (PointF itemPoint in item.GetPolygonPointFList())
                        {
                            if (Math.Abs(itemPoint.X - mousePoint.X) <= m_OffsetPX && Math.Abs(itemPoint.Y - mousePoint.Y) <= m_OffsetPX)
                            {
                                if (Control.ModifierKeys == Keys.Control)
                                {
                                    this.Cursor = System.Windows.Forms.Cursors.Hand;
                                    return;
                                }
                            }
                        }

                        if (item.GetGPath().IsVisible(mousePoint))
                        {
                            if (Control.ModifierKeys == Keys.Control)
                            {

                                this.Cursor = System.Windows.Forms.Cursors.SizeAll;
                                return;

                            }
                        }


                    }
                    else
                    {
                        if (item.GetGPath().IsOutlineVisible(mousePoint, GrayPen))
                        {
                            if (item.Myshape == ShapeType.RECTANGLE)
                            {

                                List<PointF> vertexPoint = item.GetVertexPoints();



                                foreach (PointF itemPoint in vertexPoint)
                                {
                                    if (Math.Abs(itemPoint.X - mousePoint.X) <= m_OffsetPX && Math.Abs(itemPoint.Y - mousePoint.Y) <= m_OffsetPX)
                                    {
                                        if (Control.ModifierKeys == Keys.Control)
                                        {
                                            this.Cursor = System.Windows.Forms.Cursors.Hand;
                                            return;
                                        }
                                    }
                                }


                            }
                            else
                            {
                                if (Control.ModifierKeys == Keys.Control)
                                {
                                    this.Cursor = System.Windows.Forms.Cursors.NoMove2D;
                                    return;
                                }

                            }



                        }
                        if (item.IfZoomContains(mousePoint))
                        {

                            if (Control.ModifierKeys == Keys.Control)
                            {

                                this.Cursor = System.Windows.Forms.Cursors.SizeAll;
                                return;

                            }

                        }
                    }




                }
            }
            //设置鼠标在样品上的样式
            foreach (var sam in m_visualSamples)
            {
                var item = sam.GetSampleGDIObject();
                if (!item.SelColor.Name.Equals("Transparent"))
                {
                    if (item.IfZoomContains(mousePoint))
                    {
                        if ((Control.ModifierKeys == Keys.Alt))
                        {

                            this.Cursor = System.Windows.Forms.Cursors.SizeAll;
                            return;

                        }
                    }
                }
            }

            if (e.KeyCode == Keys.Escape && m_IsDrawMeasure == true && m_DrawMeasureType == DrawMeasureAreaActionType.Polygon)
            {
                var polygonPoints = m_DrawMeasureGDIObject.GetPolygonPointFList();

                if (polygonPoints.Count > 0)
                {
                    polygonPoints.RemoveAt(polygonPoints.Count - 1);//remove the last one.
                    m_DrawMeasureGDIObject.SetPolygonPointFList(polygonPoints);


                }
                else
                {
                    m_IsDrawMeasure = false;

                }



            }
            else if (e.KeyCode == Keys.Escape && m_IsDrawMeasure == true)
            {
                m_IsDrawMeasure = false;
            }
        }
        private void OTSSamplespaceWindow_KeyUp(object sender, KeyEventArgs e)
        {
            //键盘抬起时，将选择区域的标识 设置为未选择状态
            this.Cursor = System.Windows.Forms.Cursors.Default;

            this.Invalidate();

        }

        public void KeyUps()
        {

            this.Cursor = System.Windows.Forms.Cursors.Default;
        }


        #region 处理方法总汇
        #region 清除所需图形

        public void ClearDrawInfo()
        {
            try
            {

                m_visualStage.FrameOfHoleGDIObjects.Clear();

                m_visualStage.cleargdiobj();
                var sam = GetWorkingVisualSample();

                if (sam != null)
                {


                    if (m_DrawMeasureGDIObject != null)
                    {
                        m_DrawMeasureGDIObject = null;
                    }
                }
                m_visualSamples.Clear();



            }
            catch (Exception ex)
            {

                log.Error(ex.ToString());
            }
        }
        #endregion
        #endregion




        #region 绘制样品以及测量区域
        /// <summary>
        /// 绘制样品以及测量区域
        /// </summary>
        /// <param name="SMeasrueAreaList">测量区域的集合</param>
        public void DrawSampleAndMeasureInfo(SampleMeasurePara SMeasrueArea)
        {

            var item = m_visualStage.GetHoleGDIByHoleName(SMeasrueArea.sampleHoleName);
            if (item != null)
            {
                CVisualSampleArea sam;
                if (InitVisualSample(SMeasrueArea.sampleHoleName, SMeasrueArea.sSampleName, out sam))
                {



                    if (SMeasrueArea.iShape == ShapeType.POLYGON)
                    {


                        var ps = new List<PointF>();
                        foreach (var p in SMeasrueArea.DrawPolygonPointList)
                        {
                            var ctrlcoordPoint = m_visualStage.OTSCoordToCtrlCoord(p);
                            ps.Add(ctrlcoordPoint);

                        }

                        CMeasureArea polygongdi = new CMeasureArea(ps, SMeasrueArea.iShape, SMeasrueArea.sampleHoleName, SMeasrueArea.sSampleName, Color.Red);


                        sam.SetMeasureGDIObject(polygongdi);
                        PrepareMeasureField(sam, m_MeasureAppForm.GetRunType());

                    }
                    else
                    {
                        PointF xHole = new PointF(SMeasrueArea.MeasureRect.Left, SMeasrueArea.MeasureRect.Top);
                        PointF yHole = new PointF(SMeasrueArea.MeasureRect.Right, SMeasrueArea.MeasureRect.Bottom);
                        CDisplayGDIObject gdi = m_visualStage.GetCtrlCoordRect(xHole, yHole, (GDIType)SMeasrueArea.iShape, "", "");
                        gdi.SampleName = SMeasrueArea.sSampleName;
                        gdi.NameOrHoleName = SMeasrueArea.sampleHoleName;

                        CMeasureArea measureGdi;
                        if (m_visualStage.GetMeasureGdiObjectFromSampleGdi(gdi, out measureGdi))
                        {

                            sam.SetMeasureGDIObject(measureGdi);
                            PrepareMeasureField(sam, m_MeasureAppForm.GetRunType());
                        }
                    }
                    COTSMsrPrjResultData cProjMgr = m_MeasureAppForm.m_ProjParam.GetResultData();

                    List<PointF> CompleteFieldList = cProjMgr.GetSampleByName(SMeasrueArea.sSampleName).GetMsrStatus().GetCompletedFieldsCenter();
                    if (CompleteFieldList.Count > 0)
                    {


                        ChangeCompleteFieldMeasureState(CompleteFieldList, Color.Green, sam);
                    }
                }
            }



        }
        #endregion


        #region 获取帧图信息
        public void ReadSEMDataAndSetToCurrentSample()
        {


            List<double> semParameters;


            #region 获取电镜参数
            ////获取Field操作类对象
            if (m_SEMDATAFieldManage == null)
            {
                m_SEMDATAFieldManage = new SEMDATAFieldManage(m_MeasureAppForm.m_ProjParam);
            }
            //判断是否连接电镜
            if (m_SEMDATAFieldManage.InitAndConnection())
            {
                //获取电镜参数 放大倍数与工作距离 等参数
                semParameters = m_SEMDATAFieldManage.GetSEMMagAndWDParameter();
                double mag = semParameters[0];
                double wd = semParameters[1];
                double bri = semParameters[2];
                double contra = semParameters[3];
                double kv = semParameters[4];
                if (mag != 0 && wd != 0)
                {
                    //设置样品文件中的电镜参数 
                    m_MeasureAppForm.m_ProjParam.SetWorkingSampleSEMData(wd, mag, bri, contra, kv);

                    //将右键SEM数据菜单设置为可编辑状态
                    CMStrip.Items[(int)MenuIndex.SetSemData].Enabled = true;

                }


            }

            #endregion


        }
        #region 获取Filed帧图
        public List<CVisualFieldGDIObject> GetOTSFieldVisualRects(CVisualSampleArea sam, MSR_RUN_TYPE runType)
        {
            List<Point> listCenterPoint = new List<Point>();
            Size rectSize = new Size();

            var m_ResultData = m_MeasureAppForm.m_ProjParam.GetResultData();
            var sample = m_ResultData.GetSampleByName(sam.GetSampleName());
            List<CVisualFieldGDIObject> visualfieldRects = new List<CVisualFieldGDIObject>();

            if (runType == MSR_RUN_TYPE.RUNSampleHoleImage)
            {
                InitHoleImgPosData(sample, out listCenterPoint, out rectSize);
            }
            else if (runType == MSR_RUN_TYPE.RUNMEASURE)
            {
                sample.InitFieldPosData(out listCenterPoint, out rectSize);
            }



            for (int i = 0; i < listCenterPoint.Count; i++)
            {
                //convert the center point to leftTop point of rectangle.
                Point otsPoint = listCenterPoint[i];
                int left = otsPoint.X - rectSize.Width / 2;
                int top = otsPoint.Y - rectSize.Height / 2;//the ots coordinate is leftbottom is (0,0),but the control coordinate is leftTop is (0,0),so here use minus.

                var rect = new Rectangle(new Point(left, top), rectSize);

                Point lt = new Point(rect.Left, rect.Top);
                Point rb = new Point(rect.Right, rect.Bottom);
                RectangleF visualRect = m_visualStage.GetCtrlCoordRectF(lt, rb);

                Color ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.FieldColor);


                string sampleName = sam.GetSampleName();
                string sampleHoleName = sam.GetSampleGDIObject().NameOrHoleName;


                CVisualFieldGDIObject createRect = new CVisualFieldGDIObject(visualRect, otsPoint.X, otsPoint.Y, sampleHoleName, sampleName, ColorStr);
                createRect.Enable = true;
                visualfieldRects.Add(createRect);
            }

            return visualfieldRects;


        }
        public bool InitHoleImgPosData(COTSSample sample, out List<Point> lisFieldPos, out Size iSzie)
        {
            lisFieldPos = new List<Point>();
            iSzie = new Size();

            COTSSample WSample = sample;
            if (null == WSample)
            {
                return false;
            }

            CDomain pMsrArea = WSample.GetMsrDomain();


            COTSImgScanPrm pImgScanParam = WSample.GetMsrParams().GetImageScanParam();
            COTSImageProcParam pImgProcParam = WSample.GetMsrParams().GetImageProcessParam();

            CSEMDataMsr pSEMDataMsr;


            List<PointF> listPoint = new List<PointF>();
            listPoint.Clear();


            pSEMDataMsr = new CSEMDataMsr();
            pSEMDataMsr.SetScanFieldSize100(m_visualStage.GetOTSSampleStageData().iScanFieldSize100);
            double dMagnification = m_MeasureAppForm.m_ProjParam.GetDefaultParam().GetStageDataParam().GetMinMag();//using the min mag to photo the hole image.
            pSEMDataMsr.SetMagnification(dMagnification);



            //calculate all the field position point in OTS coordination.
            if (!pFieldMgr.Init(pMsrArea, pImgScanParam, 0, pSEMDataMsr, listPoint))
            {
                return false;
            }
            lisFieldPos = pFieldMgr.GetFieldCentrePoints();



            var oValue = new COTSRect();
            if (!pFieldMgr.GetOTSRectByIndex(0, ref oValue))
            {
                return false;
            }
            iSzie = new Size((int)oValue.GetWidth(), (int)oValue.GetHeight());


            return true;
        }
        #endregion
        public void PrepareMeasureField(CVisualSampleArea visualsam, MSR_RUN_TYPE runType)
        {

            try
            {

                List<CVisualFieldGDIObject> visualfieldRects = null;

                visualfieldRects = GetOTSFieldVisualRects(visualsam, runType);//get all the possible field rects through C++ code.

                if (runType == MSR_RUN_TYPE.RUNSampleHoleImage)
                {
                    //-------maybe take more than one visualsample hole image for one sample,
                    //if the previous visual area's fields don't finish,then the unfinished field's area may overlap with the current visualsample's area.
                    // then there positions will conflict. So we should remove the unfinished fields first.
                    var completeHoleImgs = new List<CDisplayGDIObject>();
                    foreach (var holeImgfld in m_visualStage.FrameOfHoleGDIObjects)
                    {
                        if (holeImgfld.BSEImage != null)
                        {
                            completeHoleImgs.Add(holeImgfld);
                        }
                    }
                    m_visualStage.FrameOfHoleGDIObjects = completeHoleImgs;
                    //------
                    foreach (var r in visualfieldRects)
                    {
                        r.SetDisplayRefPoint(m_visualStage.GetDisplayRefPoint());
                        r.SetZoomNumber(m_visualStage.GetZoomNum());
                        RectangleF ImgRegionF;
                        float ImgRegionWidth;
                        float ImgRegionHeight;

                        ImgRegionF = r.GetOrigionalDrawRegionF();
                        ImgRegionWidth = Convert.ToInt32(ImgRegionF.Width);
                        ImgRegionHeight = Convert.ToInt32(ImgRegionF.Height);

                        //绘制图像

                        CDisplayGDIObject createImageRect = new CDisplayGDIObject(ImgRegionF, r.OTSX, r.OTSY, r.SampleName, r.NameOrHoleName, ImgRegionWidth, ImgRegionHeight, GDIType.DrawFrameOfHoleBSEImage);
                        //添加至List集合中
                        createImageRect.SetInitRegionF(r.GetOrigionalDrawRegionF());
                        createImageRect.NameOrHoleName = r.NameOrHoleName;
                        createImageRect.SetZoomNumber(m_visualStage.GetZoomNum());
                        createImageRect.SetDisplayRefPoint(m_visualStage.GetDisplayRefPoint());


                        m_visualStage.FrameOfHoleGDIObjects.Add(createImageRect);

                    }

                }
                else if (runType == MSR_RUN_TYPE.RUNMEASURE)
                {

                    visualsam.GetMeasureGDIObject().SubItems().Clear();


                    for (int i = 0; i < visualfieldRects.Count; i++)
                    {


                        visualsam.AddFieldGDIObject(visualfieldRects[i]);


                    }

                    SaveFieldPositionInfoToSample(visualsam);
                    m_MeasureAppForm.UpdatePropertyVal();
                }


            }
            catch (Exception ex)
            {
                log.Error(ex.ToString());
            }
            Invalidate();
        }
        public void SaveFieldPositionInfoToSample(CVisualSampleArea sam)
        {
            var m_ResultData = m_MeasureAppForm.m_ProjParam.GetResultData();
            var sample = m_ResultData.GetSampleByName(sam.GetSampleName());
            var fields = sam.GetMeasureFieldGDIObjects();
            sample.ClearFields();
            for (int i = 0; i < fields.Count; i++)
            {
                var f = (CVisualFieldGDIObject)fields[i];
                var otsPoint = new Point(f.OTSX, f.OTSY);
                var pixelsize = sample.CalculatePixelSize();
                var newfld = new COTSField(otsPoint, pixelsize);
                COTSRect r = new COTSRect();
                sample.pFieldMgr.GetOTSRectByIndex(i, ref r);//get this field's global position(in the whole ots coordination)
                newfld.SetOTSRect(r);
                newfld.SetMeasureSequence(f.SequenceNum);
                sample.pFieldMgr.CalculateFieldNeighbour(sample.GetFieldsData(), newfld);
                newfld.Sample = sample;
                sample.AddNewField(newfld);
            }



        }
        #endregion

        #region 设置SEM数据
        public bool SetSEMDATAMParameter(double magnification, double semWorkingDistance, double bri, double contra)
        {
            #region 获取电镜参数


            //获取Field操作类对象
            if (m_SEMDATAFieldManage == null)
            {
                m_SEMDATAFieldManage = new SEMDATAFieldManage(m_MeasureAppForm.m_ProjParam);
            }
            //判断是否连接电镜
            if (m_SEMDATAFieldManage.InitAndConnection())
            {
                //获取电镜参数
                bool mFlag;
                bool wFlag;

                mFlag = m_SEMDATAFieldManage.SetGMagnification(magnification);

                log.Warn("Set Magnification:" + magnification.ToString("F2"));
                wFlag = m_SEMDATAFieldManage.SetSemWorkingDistance(semWorkingDistance);
                log.Warn("Set WD:" + semWorkingDistance.ToString("F2"));
                bool c = m_SEMDATAFieldManage.SetSembrightness(bri);
                log.Warn("Set Brightness:" + bri.ToString("F2"));
                bool d = m_SEMDATAFieldManage.SetSemContrast(contra);
                log.Warn("Set Contrast:" + contra.ToString("F2"));
                if (mFlag && wFlag && c && d)
                {
                    return true;
                }

            }
            return false;
            #endregion
        }


        #endregion

        #region 驱动到SEM当前位置
        protected void SetMeasureToSEMLocation()
        {
            bool selWSampleMeasureStatus = m_MeasureAppForm.m_ProjParam.GetWorkSampleMeasureStatus();
            if (selWSampleMeasureStatus)
            {
                return;
            }
            try
            {
                List<double> SemLocation = new List<double>();
                if (GetSemLocation(ref SemLocation))
                {

                    PointF OTSLocation = m_MeasureAppForm.m_ProjParam.ConverSEMToOTSCoord(new PointF((int)Math.Round(SemLocation[(int)XYIndex.X], 0), (int)Math.Round(SemLocation[(int)XYIndex.Y], 0)));
                    NLog.LogManager.GetCurrentClassLogger().Warn(OTSLocation.ToString());

                    var sam = GetWorkingVisualSample();
                    var MeasureItem = sam.GetMeasureGDIObject();


                    var measurePos = m_visualStage.OTSCoordToCtrlCoord(OTSLocation);


                    MeasureItem.DraggingPoint = MeasureItem.GetCenterPoint();

                    MeasureItem.PositionAltering(measurePos, false);

                    var para = m_visualStage.GetSampleMeasurePara(MeasureItem);

                    m_MeasureAppForm.m_ProjParam.SetWorkSampleHoleAndMeasureArea(para);



                }
                Invalidate();
            }
            catch (Exception ex)
            {

                log.Error(ex.ToString());
            }
        }
        #endregion

        #region   驱动SEM到当前位置
        public bool SetSEMCurrentLocation()
        {

            bool bret = false;
            //获取Field操作类对象
            if (m_SEMDATAFieldManage == null)
            {
                m_SEMDATAFieldManage = new SEMDATAFieldManage(m_MeasureAppForm.m_ProjParam);
            }
            //判断是否连接电镜
            if (m_SEMDATAFieldManage.InitAndConnection())
            {
                bret = m_SEMDATAFieldManage.SetSEMCurrentLocation(m_MouseDownPoint, m_visualStage);


            }

            return bret;


        }
        #endregion

        #region 设置SEM到中心
        public bool SetSEMToCenterPoint()
        {
            try
            {
                //获取Field操作类对象
                if (m_SEMDATAFieldManage == null)
                {
                    m_SEMDATAFieldManage = new SEMDATAFieldManage(m_MeasureAppForm.m_ProjParam);
                }
                //判断是否连接电镜
                bool bret = false;

                var sam = GetWorkingVisualSample();
                if (m_SEMDATAFieldManage.InitAndConnection())
                {
                    bret = (m_SEMDATAFieldManage.DriveSEMToLocation(m_MouseDownPoint, m_visualStage, sam.GetMeasureFieldGDIObjects()));

                }
                return bret;
            }
            catch (Exception ex)
            {

                log.Error("OTSSamplespaceWindow_" + "SetSEMToCenterPoint" + ":" + ex.ToString() + "");
                return false;
            }
        }

        #endregion

        #region 获取SEM当前位置
        public bool GetSemLocation(ref List<double> SemLocation)
        {

            //获取Field操作类对象
            if (m_SEMDATAFieldManage == null)
            {
                m_SEMDATAFieldManage = new SEMDATAFieldManage(m_MeasureAppForm.m_ProjParam);
            }
            //判断是否连接电镜
            bool bret = false;
            if (m_SEMDATAFieldManage.InitAndConnection())
            {
                bret = m_SEMDATAFieldManage.GetSemLocation(ref SemLocation);



            }
            return bret;

        }
        #endregion
        #region 显示标尺
        /// <summary>
        /// 是否显示标尺控件
        /// </summary>
        /// <param name="b_show"></param>
        public void ShowRulerLocation()
        {

            //设置标尺位置
            Point rulerLocation = new Point(10, this.Height - (int)(control_Ruler2.Height * 2));
            this.control_Ruler2.Location = rulerLocation;

            control_Ruler2.Visible = true;

            var m_GlobalZoomNum = m_visualStage.GetZoomNum();
            f_ruler_size = Convert.ToInt32(f_old_ruler_size * m_GlobalZoomNum);
            control_Ruler2.RulerWidth = Convert.ToInt32(f_ruler_size);
            control_Ruler2.Value = 1;

            //放大过长时，这里将宽度与代表的实际宽度进行折半显示
            while (control_Ruler2.Width > 300)
            {
                control_Ruler2.RulerWidth = Convert.ToInt32(control_Ruler2.RulerWidth) / 2;
                control_Ruler2.Value = control_Ruler2.Value * 2;
            }
            control_Ruler2.SetValue(control_Ruler2.RulerWidth, control_Ruler2.Value.ToString());

        }
        public void RulerInit(StageDrawingData SData)
        {
            control_Ruler2.ShowString = "1mm";
            PointF xDomain = new PointF(SData.StageDomain.Left, SData.StageDomain.Top);
            PointF yDomain = new PointF(SData.StageDomain.Right, SData.StageDomain.Bottom);

            //OTS宽度高度差值
            float widthDomain = Math.Abs(yDomain.X - xDomain.X);
            int length = this.Height > this.Width ? this.Width : this.Height;
            control_Ruler2.RulerWidth = (int)(length / widthDomain * 1000);
            f_ruler_size = f_old_ruler_size = control_Ruler2.RulerWidth;
            control_Ruler2.Value = 1000;
        }
        #endregion


        #region 隐藏与显示样品孔照片
        static bool IsShowSampleHoleImage = true;
        public void ChangeSampleHoleImage()
        {
            IsShowSampleHoleImage = IsShowSampleHoleImage ? false : true;
            Invalidate();
        }
        #endregion

        #region 添加样品孔中BSE图像信息
        public void AddHoleBSEImageData(byte[] ImageData, int width, int height, Point fieldPos, int fieldId)
        {

            CDisplayGDIObject itemWorkSample;


            itemWorkSample = GetWorkingVisualSample().GetSampleGDIObject();
            //获取样品孔BSE图像
            Image bseImage;
            int m_iWidth = width;
            int m_iHeigh = height;

            if (m_visualStage.FrameOfHoleGDIObjects.Count > 0)
            {
                for (int i = 0; i < m_visualStage.FrameOfHoleGDIObjects.Count; i++)
                {

                    var ctrlPos = m_visualStage.OTSCoordToCtrlCoord(fieldPos);
                    if (m_visualStage.FrameOfHoleGDIObjects[i].BSEImage == null)// prevent miss match when this sample area is overlaying on the other area(already took image in the field)
                    {
                        if (m_visualStage.FrameOfHoleGDIObjects[i].IfContains(ctrlPos))
                        //if (i == fieldId)
                        {


                            bseImage = CImageHandler.ToGrayBitmap(ImageData, m_iWidth, m_iHeigh);
                            m_visualStage.FrameOfHoleGDIObjects[i].BSEImage = bseImage;
                            if (m_MeasureAppForm.MeasureThreadRunFlag)//only when it's in running mode,we update the samplehole image.prvent conflict using of sampleHoleImageBuffer.BSEImage
                            {
                                DrawSampleHoleImage(m_visualStage.FrameOfHoleGDIObjects[i]);
                            }


                            break;
                        }
                    }

                }
            }
            //显示样品孔照片
            IsShowSampleHoleImage = true;
            Invalidate();
        }
        #endregion

        #region 删除样品孔中BSE图像信息

        public void DeleteHoleBSEImageDataNoMessageBox()
        {


            m_visualStage.FrameOfHoleGDIObjects.Clear();
            //sampleHoleImageBuffer = new CDisplayGDIObject(new RectangleF(0, 0, this.Width, this.Height), CreateRectangleType.SampleHoleImageBuffer); ;
            var w = sampleHoleImageBuffer.BSEImage.Width;
            var h = sampleHoleImageBuffer.BSEImage.Height;
            sampleHoleImageBuffer.BSEImage = new Bitmap(w, h);

            Invalidate();

        }

        #endregion



        #region 复位工作样品区域
        public CDisplayGDIObject ResetMeasure(CDisplayGDIObject SampleGDIObjects, CMeasureArea MeasureGDIObjects)
        {


            m_visualStage.GetMeasureGdiObjectFromSampleGdi(SampleGDIObjects, out MeasureGDIObjects);


            return MeasureGDIObjects;

        }
        public void InverseSelectWorkSampleMeasure()
        {
            //COTSSample WSample = m_MeasureAppForm.m_ProjParam.GetWorkSample();
            //var stype = m_MeasureAppForm.m_ProjParam.GetDefaultParam().GetSysType();
            //OTSSampleVisualPropertyInfo MeasureInfo = new OTSSampleVisualPropertyInfo(WSample, stype);

            //RectangleF measureSize = m_MeasureAppForm.m_ProjParam.CalculateMsrArea(MeasureInfo.SMeasurePara.sampleHoleName);
            ////获取位置与尺寸
            //MeasureInfo.SMeasurePara.MeasureRect.Location = measureSize.Location;
            //MeasureInfo.SMeasurePara.MeasureRect.Size = measureSize.Size;
            ////获取样品信息
            //PointF xHole = new PointF(MeasureInfo.SMeasurePara.MeasureRect.Left, MeasureInfo.SMeasurePara.MeasureRect.Top);
            //PointF yHole = new PointF(MeasureInfo.SMeasurePara.MeasureRect.Right, MeasureInfo.SMeasurePara.MeasureRect.Bottom);


            ////定义测量区域
            //RectangleF SampleRectangleF = m_visualStage.GetCtrlCoordRectF(xHole, yHole);
            //CDisplayGDIObject m_MeasureGDIObject = m_visualStage.GetCtrlCoordRect(xHole, yHole, (GDIType)MeasureInfo.SMeasurePara.iShape, "", "");
            //m_MeasureGDIObject.SetInitRegionF(SampleRectangleF);

            //var sam = GetWorkingVisualSample();
            //var mea = sam.GetMeasureGDIObject();
            //CMeasureArea m_ResetMeasureGDIobjects = ResetMeasure(sam.GetSampleGDIObject(), m_MeasureGDIObject);
            //mea.SetInitRegionF(m_ResetMeasureGDIobjects.GetOrigionalDrawRegionF());
            //mea.Shape = m_ResetMeasureGDIobjects.Shape;
            m_DrawMeasureType = DrawMeasureAreaActionType.InverseSelection;
            m_IsDrawMeasure = true;
            m_DrawMeasureGDIObject = null;
            this.Cursor = Cursors.Hand;
            //Invalidate();

        }



        #endregion

        private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
        {
            this.OnMouseDown(e);
        }

        private void pictureBox1_Paint(object sender, PaintEventArgs e)
        {


            OnPaint(e, GetAllVisualFieldGdiObject());

            if (m_DrawMeasureGDIObject != null)
            {

                m_DrawMeasureGDIObject.OnPaint(e);
            }



            if (m_DrawPolygonFinishGDIObject != null) m_DrawPolygonFinishGDIObject.OnPaint(e);
        }

        private void pictureBox1_MouseUp(object sender, MouseEventArgs e)
        {
            this.OnMouseUp(e);
        }

        private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
        {
            this.OnMouseMove(e);
        }

    }
}