OTS/OTSIncAMeasureApp/4-OTSSamplespaceGraphicsPanel/OTSSamplespaceWindow.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using OTS.WinFormsUI.Docking;

using System.Collections;
using OTSDataType;
using OTSModelSharp;
using MyControls;
using OTSModelSharp.ServiceInterface;
using OTSMeasureApp._4_OTSSamplespaceGraphicsPanel;
using static OTSDataType.otsdataconst;

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 partial class OTSSamplespaceWindow : DockContent
    {
        #region 全局变量定义

        public CVisualStage m_visualStage;

        //样品孔的List集合
        string m_SampleHoleSelectName = string.Empty;
        public  string m_SampleSelectName = string.Empty;
      

        public List<CVisualSampleArea> m_visualSamples;


        //BSE图像
        public static List<CRectangleGDIObject> m_ImageGDIObjects;
        //BSE图像帧图 为了获取位置与尺寸
        public static List<CRectangleGDIObject> m_ImageOfFieldGDIObjects;
        //手绘测量区域
        public static CRectangleGDIObject m_DrawMeasureGDIObject=new CRectangleGDIObject();
 
        //多边形测量区域完成标识
        public static CRectangleGDIObject 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;
        //手动绘制测量区域的形状类型
        CreateRectangleType m_DrawMeasureType = (CreateRectangleType)1;

        //是否手绘标识
         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;
        #region 设置双缓冲
        /// <summary>
        /// 设置双缓冲
        /// </summary>
        public void SetDoubleBufferByIsDraw()
        {
            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true); // 禁止擦除背景.
            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true); // 双缓冲
        }
        #endregion

        #region 构造函数 获取父窗体对象
        public OTSSamplespaceWindow(OTSIncAMeasureAppForm MeasureAppForm)
        {
            InitializeComponent();
            m_MeasureAppForm = MeasureAppForm;
          
            SetDoubleBufferByIsDraw();// 双缓冲
       
          
            //国际化
            lan = new OTSCommon.Language(this);
            table = lan.GetNameTable(this.Name);
        }

        /// <summary>
        /// 画圆形测试区域 事件
        /// </summary>
        public void DrawCircleMeasure()
        {
            //手绘测量区域类型为圆形
            m_DrawMeasureType = CreateRectangleType.Circle;
            m_IsDrawMeasure = true;
            this.Cursor = Cursors.Hand;
        }
        /// <summary>
        /// 画矩形测试区域 事件
        /// </summary>
        public void DrawRectangleMeasure()
        {
            //手绘测量区域类型为矩形
            m_DrawMeasureType = CreateRectangleType.SampleBackGround_Rectangle;
         
            m_IsDrawMeasure = true;
            this.Cursor = Cursors.Hand;
        }
        /// <summary>
        /// 画多边形测试区域 事件
        /// </summary>
        public void DrawPolygonMeasure()
        {
            m_DrawMeasureType = CreateRectangleType.Polygon;
            m_IsDrawMeasure = true;
       
            this.Cursor = Cursors.Hand;
        }

        /// <summary>
        /// 三点画圆形测试区域 事件  先多边形后圆形
        /// </summary>
        public void DrawCircleMeasureByThreePoints()
        {
            //手绘测量区域类型为圆形
            m_DrawMeasureType = CreateRectangleType.CircleByThreePoints;
            m_IsDrawMeasure = true;
      
            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 rectangle = new RectangleF(position, size);
                Color MeasureColor = Color.Red;
                CRingGDIObject newGDI;
               
                newGDI = new CRingGDIObject(rectangle, CreateRectangleType.RingShape, 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);


            }

           

           
        }
        #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.m_SPropertyWindows.TSSaveAs.Enabled = true;
                    m_MeasureAppForm.m_SPropertyWindows.TSLoad.Enabled = true;
                    m_MeasureAppForm.m_SPropertyWindows.TSEdit.Enabled = false;
                    m_MeasureAppForm.m_SPropertyWindows.TSEdit.Visible = false;

                    //添加样品
                    m_MeasureAppForm.AddNewSampleMeasure(m_SampleHoleSelectName);
                    ReadSEMDataFromSEM();
                    break;
                case "DeleteStage":
                    //删除样品
                    DeleteSampleInfo(m_SampleSelectName);
                    break;
                case "DriveSEMToCenterLocation":
                    //驱动SEM到中心位置
                    SetSEMToCenterPoint();
                    break;
                case "DriveSEMToCurrentLocation":
                    //驱动SEM到当前位置
                    SetSEMCurrentLocation();
                    break;
                case "SetSEMCenterLocation":
                    //将测量区域移到SEM当前位置
                    SetMeasureToSEMLocation();

                    break;
                case "ReadSEMData":
                    m_MeasureAppForm.SetRunType(MSR_RUN_TYPE.RUNMEASURE);
                  
                    ReadSEMDataFromSEM();
                    PrepareMeasureField(GetWorkingVisualSample(), MSR_RUN_TYPE.RUNMEASURE);
                  
                    break;
                case "SetSemData":
                    double SemMag = 0;
                    double dDistance = 0;
                    if (m_MeasureAppForm.m_ProjParam.GetMagAndDistance(ref SemMag, ref dDistance))
                    {
                        //设置SEM数据

                        if (!SetSEMDATAMParameter(SemMag, dDistance))
                        {
                            log.Error("Failed SetSemData:--Mag:" + SemMag + "--Distance:" + dDistance + "--");
                        }
                    }
                    break;
                case "ShootBSEPicture":
                    //设置消息类型 拍摄样品孔
                    m_MeasureAppForm.SetRunType(MSR_RUN_TYPE.RUNSampleHoleImage);
                   
                    //清除原图片信息
                    DeleteHoleBSEImageDataNoMessageBox();
                  
                    PrepareMeasureField(GetWorkingVisualSample(), MSR_RUN_TYPE.RUNSampleHoleImage);
                  
                    GetBSEPictures();
                    break;
                case "DeleteBSEPicture":
                    DeleteHoleBSEImageData();
                    break;
                case "SlopFocusMenuItem":

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

                    slopFocus.Show();

                    break;
            }
        }
        #endregion
        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 OpenExistSampleFile(CStage SStage, CSEMStageData SEMStageData, List<SampleMeasurePara> SMeasrueParaList)
        {
            m_visualStage.clear();
            m_visualStage.InitSampleStageData(SStage, SEMStageData, this.Width, this.Height);
            m_visualStage.DrawSampleStage();
            m_visualSamples.Clear();
            foreach (var SMeasrueArea in SMeasrueParaList)
            {
                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 (AddVisualSample(SMeasrueArea.sampleHoleName, SMeasrueArea.sSampleName, out sam))
                        {
                            if (SMeasrueArea.iShape == (ShapeType)CreateRectangleType.Polygon)
                            {
                                var ps = new List<PointF>();
                                foreach (var p in SMeasrueArea.DrawPolygonPointList)
                                {
                                    var ctrlcoordPoint = m_visualStage.OTSCoordToCtrlCoord(p);
                                    ps.Add(ctrlcoordPoint);

                                }

                                CRectangleGDIObject polygonGdi = new CRectangleGDIObject(ps, CreateRectangleType.Polygon, (ShapeType)SMeasrueArea.iShape, 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);
                                CRectangleGDIObject gdi = m_visualStage.GetCtrlCoordRect(xHole, yHole, (CreateRectangleType)SMeasrueArea.iShape, "", "");
                                gdi.SampleName = SMeasrueArea.sSampleName;
                                gdi.NameOrHoleName = SMeasrueArea.sampleHoleName;
                                gdi.Shape = SMeasrueArea.iShape;
                                CRectangleGDIObject measureGdi;
                                if (m_visualStage.GetMeasureGdiObjectFromSampleGdi(gdi, out measureGdi))
                                {

                                    sam.SetMeasureGDIObject(measureGdi);
                                    
                                }
                            }

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

                            foreach (var fld in FldDatas)
                            {

                         
                                float micronWidth = (float)fld.Width * (float)fld.GetPixelSize();
                                float micronHeight = (float)fld.Height * (float)fld.GetPixelSize();
                      
                                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);

                                string ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SingleColor);


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


                                CRectangleGDIObject createRect = new CRectangleGDIObject(visualRect,(int)fld.GetOTSPosition().X,(int)fld.GetOTSPosition().Y,  CreateRectangleType.FieldRectangle, sampleHoleName, sampleName, ColorTranslator.FromHtml(ColorStr));

                                visualfieldRects.Add(createRect);
                           
                            }

                            sam.GetMeasureGDIObject().SubItems().Clear();
                            //添加帧图列表
                            int sequenceNum = 0;
                            foreach (var r in visualfieldRects)
                            {
                                if (sam.GetMeasureGDIObject().ifRectangleIntersect(r))//filter the unmeasure fields
                                {
                                    r.SequenceNum = sequenceNum++;
                                    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);
                            }
                        }
                    }



                }

            }
            
                SwitchWorkSample(SMeasrueParaList[0].sSampleName);
                m_SampleSelectName = SMeasrueParaList[0].sSampleName;
            
            //重新绘制
            Invalidate();
        }
      

        public void SwitchWorkSample(string sNewWSampleName, bool bDrawField = false)
        {
            try
            {
                for (int i = 0; i < m_visualSamples.Count; i++)
                {
                    //获取颜色
                    if (m_visualSamples[i].GetSampleName() == sNewWSampleName)
                    {
                        string ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleSelColor);
                        m_visualSamples[i].GetSampleGDIObject().SelColor = ColorTranslator.FromHtml(ColorStr);
                        m_visualSamples[i].SetIsWorkSample(true);
                    }
                    else 
                    {
                        string SampleColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleColor);
                        m_visualSamples[i].GetSampleGDIObject().SelColor = ColorTranslator.FromHtml(SampleColorStr);
                        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)
            {
                ChangeDoneMeasureState(vsSam,p, changeColor);
                       
            }
          
        }
        public void ChangeDoneMeasureState(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

        #region 修改样品选择状态
        public  void SetSampleState(Color setColor)
        {
            foreach (var items in m_visualSamples)
            {
                if (items.GetSampleGDIObject().IsDragging)
                {
                    //设置颜色
                    string ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleSelColor);
                    items.GetSampleGDIObject().SelColor = ColorTranslator.FromHtml(ColorStr);
                }
                else
                {
                    items.GetSampleGDIObject().SelColor = setColor;
                }
            }
        }
       
        public  bool DeleteSample(string SampleName)
        {

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

            string ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleColor);
            SetSampleState(ColorTranslator.FromHtml(ColorStr));
            SetMeasureState(ColorTranslator.FromHtml(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.Shape = 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)
                {
                    //设置颜色
                    string ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleColor);
                    itemSample.GetSampleGDIObject().SelColor = ColorTranslator.FromHtml(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 AddVisualSample(string SampleHoleName, string SampleName,out CVisualSampleArea outsample)
        {



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

            itemAdd = m_visualStage.GetHoleGDIByHoleName(SampleHoleName);
            if (itemAdd != null)
            {
                //获取样品台类型
                var shape = itemAdd.Shape;
                //设置颜色
                string ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleSelColor);
                Color selColor = ColorTranslator.FromHtml(ColorStr);
                CRectangleGDIObject sample =new CRectangleGDIObject (itemAdd.GetOrigionalDrawRegionF(), CreateRectangleType.SelectSample, shape, 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();

            //图像隐藏
            HideMessureStatuWindowBSEImage(m_MeasureAppForm);
                //将测量结果信息状态初始化
            InitMeasureStateInfo();
           
          
                if (m_visualSamples.Count == 0)
                {
                    //将测量状态初始化
                    m_MeasureAppForm.m_MessureStatuWindow.SetMeasureStatusInit();
                }

          
            Invalidate();
        }
        
        public void HideMessureStatuWindowBSEImage(OTSIncAMeasureAppForm m_MeasureApps)
        {
            m_MeasureApps.m_MessureStatuWindow.pbBSEImage.Hide();
        }
        #region 将测量状态进度窗口信息初始化
        public void InitMeasureStateInfo()
        {
           m_MeasureAppForm.m_MeasureRetWindow.SetInit();
        }
        #endregion
       
        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>();
              
       
                //样品孔BSE图像
                m_ImageGDIObjects = new List<CRectangleGDIObject>();
                //BSE图像帧图为了获取位置与尺寸
                m_ImageOfFieldGDIObjects = new List<CRectangleGDIObject>();
      
            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();
           
        }
        public static void SetShowCMStrip(ContextMenuType IsSelectType, ContextMenuStrip cmStrip, bool IsTrue)
        {

            switch (IsSelectType)
            {
                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.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.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 = IsTrue;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCurrentLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.ShootBSEPicture].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteBSEPicture].Enabled = IsTrue;
                    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 = false;
                    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 = IsTrue;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCenterLocation].Enabled = IsTrue;
                    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.SlopFocus].Enabled = false;
                    break;
                case ContextMenuType.SampleHoleBSEImage:
                    cmStrip.Items[(int)MenuIndex.AddSample].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.DeleteSample].Enabled = IsTrue;
                    cmStrip.Items[(int)MenuIndex.ReadSEMData].Enabled = IsTrue;
                    cmStrip.Items[(int)MenuIndex.SetSemData].Enabled = IsTrue;
                    cmStrip.Items[(int)MenuIndex.SetSEMCenterLocation].Enabled = IsTrue;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCenterLocation].Enabled = IsTrue;
                    cmStrip.Items[(int)MenuIndex.DriveSEMToCurrentLocation].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.ShootBSEPicture].Enabled = IsTrue;
                    cmStrip.Items[(int)MenuIndex.DeleteBSEPicture].Enabled = true;
                    cmStrip.Items[(int)MenuIndex.SlopFocus].Enabled = IsTrue;                   
                    break;
            }
        }
        private List<CRectangleGDIObject> GetAllVisualSampleGDIObject()
        {
            List<CRectangleGDIObject> allobj = new List<CRectangleGDIObject>();
            foreach (var s in m_visualSamples)
            {
                allobj.Add(s.GetSampleGDIObject());
                allobj.Add(s.GetMeasureGDIObject());
                foreach (var f in s.GetMeasureFieldGDIObjects())
                {
                    allobj.Add(f);

                }


            }


            return allobj;


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


            return allobj;


        }
        private List<CRectangleGDIObject> GetAllVisualFieldGdiObject()
        {
            List<CRectangleGDIObject> allobj = new List<CRectangleGDIObject>();
            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;
        }
        protected override void OnMouseDown(MouseEventArgs e)
        {
            lblFocus.Focus();
       
            Point _Point ;
         
            //判断当前是否手绘
            if (m_IsDrawMeasure)
            {
                this.m_MouseDownPoint = new Point(e.X, e.Y);

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

                //绘制多边形 测量区域
                if (m_DrawMeasureType == CreateRectangleType.Polygon)
                {
                    if (m_DrawMeasureGDIObject == null)
                    {
                        m_DrawMeasureGDIObject = new CRectangleGDIObject(new List<PointF>(), CreateRectangleType.Polygon, (ShapeType)m_DrawMeasureType, 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);
                            CRectangleGDIObject polygonGdi =new CRectangleGDIObject (polygonPoints, CreateRectangleType.Polygon, (ShapeType)m_DrawMeasureType, 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
                            m_MeasureAppForm.SetRunType(MSR_RUN_TYPE.RUNMEASURE);
                            //CMeasureThreadWrapper.SetDoRunType(MSR_THREAD_RunSTATUS.RUNMEASURE);
                            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 == CreateRectangleType.CircleByThreePoints)
                {
                    if (m_DrawMeasureGDIObject == null)
                    {
                         m_DrawMeasureGDIObject = new CRectangleGDIObject(new List<PointF>(), CreateRectangleType.Polygon, (ShapeType)m_DrawMeasureType, sampleHoleName, sampleName, Color.Red);
                    }
                    var m_PolygonPoint = m_DrawMeasureGDIObject.GetPolygonPointFList();
                
                    m_PolygonPoint.Add(m_MouseDownPoint);
              
                
                    if (m_PolygonPoint.Count == 3)//three point can make a circle .
                    {
                     
                        m_DrawMeasureType = (int)CreateRectangleType.Circle;
                        float r = 0;
                        PointF Centerpoint ;
                        GetTriangleExcenterRadius(m_PolygonPoint[0], m_PolygonPoint[1], m_PolygonPoint[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;
                        CRectangleGDIObject CRectangleGDI =new CRectangleGDIObject (rectangleThree,  CreateRectangleType.CircleByThreePoints, (ShapeType)m_DrawMeasureType, sampleName, 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;

                        var para = m_visualStage.GetSampleMeasurePara(sam1.GetMeasureGDIObject());
                        m_MeasureAppForm.m_ProjParam.SetWorkSampleHoleAndMeasureArea(para);

                        m_MeasureAppForm.SetRunType(MSR_RUN_TYPE.RUNMEASURE);
                        //CMeasureThreadWrapper.SetDoRunType(MSR_THREAD_RunSTATUS.RUNMEASURE);
                    
                        m_MeasureAppForm.SwitchWSample(m_SampleSelectName);
                        Invalidate();
                       


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

                    }
                    return;
                }
                else
                {
                   

                        var measureArea = new Rectangle(this.m_MouseDownPoint, new Size(2, 2));
                        if (m_visualStage.CheckMeasureAreaIsBeyondStageArea(measureArea))
                        {
                            m_IsDrawMeasure = true;
                        }
                        else
                        {
                            m_IsDrawMeasure = false;
                            return;
                        }
                        int sizeWH = 5;
                        Size size = new Size(sizeWH, sizeWH);
                        Rectangle rectangle = new Rectangle(m_MouseDownPoint, size);
                        Color MeasureColor = Color.Red;
                        CRectangleGDIObject newGDI;
                  
                        newGDI = new CRectangleGDIObject(rectangle, CreateRectangleType.MeasureArea, (ShapeType)m_DrawMeasureType, 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, false);

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

                    var sam2 = GetWorkingVisualSample();
                    if (sam2 != null)
                    {
                        foreach (CRectangleGDIObject item in sam2.GetMeasureFieldGDIObjects())
                        {
                            if (item.IfZoomContains(e.Location))
                            {
                                //样品孔菜单

                                _Point = this.PointToClient(Cursor.Position);
                                bool IsTrue = false;
                                //设置编辑右键菜单项
                                foreach (CRectangleGDIObject imageItem in m_ImageGDIObjects)
                                {
                                    if (imageItem.SampleName == item.SampleName)
                                    {
                                        IsTrue = true;
                                        break;
                                    }
                                }
                                //设置编辑右键菜单项
                                SetShowCMStrip(ContextMenuType.FieldMenu, CMStrip, IsTrue);                       
                                this.CMStrip.Show(this, _Point);
                                return;
                            }
                        }

                    }
                    
           

                    foreach(var item in m_visualSamples)
                    { 
                                bool isSelMeasure = false;
                                if (item.GetMeasureGDIObject().CreateType == CreateRectangleType.Polygon)
                                {
                    
                                     if(item.GetMeasureGDIObject().GetGPath().IsVisible(e.Location))
                                    {
                                        isSelMeasure = true;
                                    }
                                }
                                else
                                {
                                    if (item.GetMeasureGDIObject().IfZoomContains(e.Location) /*&& !item.MeasureGDIObject.SelColor.Name.Equals("Transparent")*/)
                                    {
                                        isSelMeasure = true;
                                        int WH = 2;
                                        Rectangle rect = new Rectangle(e.Location, new Size(WH, WH));
                                       
                                        if (!m_visualStage.CheckMeasureAreaIsBeyondStageArea(rect))
                                        {
                                            break;
                                        }
                                    }
                                }
                                if (isSelMeasure)
                                {
                          

                                    //删除BSE照片
                                    bool IsTrue = false;
                                    //设置编辑右键菜单项
                                    foreach (CRectangleGDIObject imageItem in m_ImageGDIObjects)
                                    {
                                        if (imageItem.SampleName == item.GetSampleName())
                                        {
                                            IsTrue = true;
                                            break;
                                        }
                                    }
                               
                                    //设置编辑右键菜单项
                                    SetShowCMStrip(ContextMenuType.MeasureMenu, CMStrip, IsTrue);
                                    _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.IsSelect = true;
                                        item.SetIsWorkSample(true);
                                        //设置工作样品
                                        m_MeasureAppForm.SwitchWSample(m_SampleSelectName);
                                        Invalidate();
                                    }
                                    return;
                                }
                    }
               
                    foreach (CRectangleGDIObject item in m_ImageGDIObjects)
                    {
                        if (item.IfZoomContains(e.Location))
                        {
                            //样品孔菜单
                           
                            _Point = this.PointToClient(Cursor.Position);
                            //设置编辑右键菜单项
                            SetShowCMStrip(ContextMenuType.SampleHoleBSEImage, CMStrip, false);
                            this.CMStrip.Show(this, _Point);
                            return;
                        }
                    }
                    //只点击样品上(测量区域被移动到其他地方)
                    for (int i = m_visualSamples.Count - 1; i >= 0; i--)
                    {
                        if (m_visualSamples[i].GetSampleGDIObject().IfZoomContains(e.Location))
                        {
            
                          
                            //样品菜单
                           var _IsSelectType =ContextMenuType.SampleMenu;
                            //将删除样品与测量 设置为不可编辑状态
                            _Point = this.PointToClient(Cursor.Position);
                            bool flag = false;
                       
                            if (m_visualSamples[i].GetMeasureGDIObject().IfZoomContains(e.Location))
                            {
                                //测量区域菜单
                                _IsSelectType = ContextMenuType.MeasureMenu;
                                     
                                break;
                            }
                         
                            //设置编辑右键菜单项
                            SetShowCMStrip(_IsSelectType, CMStrip, flag);
                            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;
                        }
                    }
                    //点击样品孔
                  
                    CRectangleGDIObject gdiitem;
                        if (m_visualStage.IfMouseInSampleHole(e.Location,out gdiitem))
                        {
                         
                    
                        
                            _Point = this.PointToClient(Cursor.Position);
                            //设置编辑右键菜单项
                            SetShowCMStrip(ContextMenuType.SampleHoleMenu, CMStrip, false);
                            //将删除样品与测量 设置为不可编辑状态
                            this.CMStrip.Show(this, _Point);
                            
                            m_SampleHoleSelectName = gdiitem.NameOrHoleName;
                           
                            return;
                        }
                   
                   
                        if (m_visualStage.IfMouseInStage(e.Location))
                        {
                           
                            //设置编辑右键菜单项
                            SetShowCMStrip(ContextMenuType.SampleStateMenu, CMStrip, false);
                            _Point = this.PointToClient(Cursor.Position);
                            this.CMStrip.Show(this, _Point);
                            return;
                        }
                    

                    return;
                }
                else if(e.Button == MouseButtons.Left)
                {
                    //如果正在进行测量线程，则退出鼠标点击操作
                    if (m_MeasureAppForm.MeasureThreadRunFlag)
                    {
                        return;
                    }
                   
                    CRectangleGDIObject stageobj;
                    if (m_visualStage.IfMouseInStage(e.Location, out stageobj))
                    { 
           
                        MouseDownFunction(m_visualStage.GetAllGDIObject(), e);
                        //样品
                        MouseDownFunction(GetAllVisualSampleGDIObject(), e);


                        //样品台中BSE图片
                        MouseDownFunction(m_ImageGDIObjects, e);

                    }

                    //测量区域
                    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.CreateType == CreateRectangleType.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))
                    {
                        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);
                              
                                //获取颜色
                                string ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleSelColor);
                                sam1.GetSampleGDIObject().SelColor = ColorTranslator.FromHtml(ColorStr);


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

                                break;
                            }
                        }
                      
                    }

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


      
        protected override void OnMouseMove(MouseEventArgs e)
        {
    
            if (m_MeasureAppForm.MeasureThreadRunFlag)
            {
                return;
            }
        
            if (m_IsDrawMeasure)
            {
                this.m_MouseMovePoint = new Point(e.X, e.Y);

                if (m_DrawMeasureGDIObject == null) return;//the object must be initialized by mousedown event.
                //绘制多边形
                if (m_DrawMeasureType == CreateRectangleType.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));
                                CRectangleGDIObject createPolygonFinish = new CRectangleGDIObject(pRect, CreateRectangleType.DrawPolygonFinish, "", "", Color.Green);
                                m_DrawPolygonFinishGDIObject = createPolygonFinish;

                            }
                        }
                        else
                        {
                            m_DrawPolygonFinishGDIObject = null;
                            m_IsDrawPolygonFinish = false;
                        }
                    }
                    
                }
                //圆形三点法
                else if (m_DrawMeasureType == CreateRectangleType.CircleByThreePoints)
                {
                    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 == (int)CreateRectangleType.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 == (int)CreateRectangleType.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 == (int)CreateRectangleType.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 == (int)CreateRectangleType.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))//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( vertex point of rectangle).
                    {

                                        if (curMeasureGdi.CreateType == CreateRectangleType.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.Shape == 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_ImageGDIObjects, e);
              

           }

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

        }

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

            //判断当前是否手绘
          
                if (m_IsDrawMeasure)
                {
                    
                        //绘制多边形
                        if (m_DrawMeasureType != CreateRectangleType.Polygon && m_DrawMeasureType != CreateRectangleType.CircleByThreePoints)
                        {

                            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)
            {

                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);
   
        
           
            //样品孔中BSE图片
            MouseUpFucntion(m_ImageGDIObjects, e);

          
        
       }
        protected override void OnPaint(PaintEventArgs e)//处理重绘情况
        {
           
            OnPaint(e, m_visualStage.GetAllGDIObject());

           

            OnPaint(e, GetOnlyVisualSampleGDIObject());

            if (IsShowSampleHoleImage)
            {
                if (m_ImageGDIObjects.Count > 0)
                {
                    OnPaint(e, m_ImageGDIObjects);
                }
            }
            OnPaint(e, GetAllVisualFieldGdiObject());

            if (m_DrawMeasureGDIObject != null)
            {
               
                m_DrawMeasureGDIObject.OnPaint(e);
            }
           

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

           
        }
        public  void OnPaint(PaintEventArgs e, List<CRectangleGDIObject> m_ObjectGDIObjects)//处理重绘情况
        {
            foreach (CRectangleGDIObject item in m_ObjectGDIObjects)
            {
                if (item != null)
                {
                    item.OnPaint(e);
                }
            }
        }
        protected override void OnMouseWheel(MouseEventArgs e)
        {
            var currentZoomNum = m_visualStage.GetZoomNum();
            //如果正在进行测量线程，则退出鼠标点击操作
            if (m_MeasureAppForm.MeasureThreadRunFlag)
            {
                return;
            }
            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(m_ImageGDIObjects, e.Location, currentZoomNum);

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



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

        private  void MouseWheelFunction(List<CRectangleGDIObject> objList, Point mousePoint, float ZoomNum)
        {
            
            for (int i = 0; i < objList.Count; i++)
            {
               
                    objList[i].Zoom(mousePoint, ZoomNum);
            }
        }
        #endregion

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

            foreach (CRectangleGDIObject item in objList)
            {
                item.IsMoving = true;
                item.DraggingPoint = e.Location;
            }
        }
        public void MouseMoveFucntion(List<CRectangleGDIObject> objList, MouseEventArgs e)
        {
            foreach (CRectangleGDIObject item in objList)
            {
                if (item.IsMoving)
                {
                  
                    item.Move(e.Location);
                   
                }
            }
        }
       
      
        public void MouseUpFucntion(List<CRectangleGDIObject> objList, MouseEventArgs e)
        {
            foreach (CRectangleGDIObject 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);
            }
        }
        private void OTSSamplespaceWindow_KeyDown(object sender, KeyEventArgs e)
        {
            KeyDowns();
        }
        private void OTSSamplespaceWindow_KeyUp(object sender, KeyEventArgs e)
        {
            //键盘抬起时，将选择区域的标识 设置为未选择状态
            this.Cursor = System.Windows.Forms.Cursors.Default;
       
                this.Invalidate();
          
        }
        public void KeyDowns()
        {
            //鼠标相对于屏幕的坐标
            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.CreateType == CreateRectangleType.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.Shape == 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;
                           
                        }
                    }
                }
            }
        }
        public void KeyUps()
        {

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

        #region 处理方法总汇
        #region 清除所需图形
   
        public void ClearDrawInfo()
        {
            try
            {
               
                    m_visualStage.cleargdiobj();

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


            }
            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 (AddVisualSample(SMeasrueArea.sampleHoleName, SMeasrueArea.sSampleName,out sam))
                            {
                               

                   
                                if (SMeasrueArea.iShape ==(ShapeType) CreateRectangleType.Polygon)
                                {
                           
                                 
                                    var ps = new List<PointF>();
                                    foreach (var p in SMeasrueArea.DrawPolygonPointList)
                                    {
                                        var ctrlcoordPoint = m_visualStage.OTSCoordToCtrlCoord(p);
                                        ps.Add(ctrlcoordPoint);
                                
                                    }
                                 
                                    CRectangleGDIObject polygongdi =new CRectangleGDIObject (ps, CreateRectangleType.Polygon, (ShapeType)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);
                                    CRectangleGDIObject gdi = m_visualStage.GetCtrlCoordRect(xHole,yHole, (CreateRectangleType)SMeasrueArea.iShape, "", "");
                                    gdi.SampleName = SMeasrueArea.sSampleName;
                                    gdi.NameOrHoleName = SMeasrueArea.sampleHoleName;
                                    gdi.Shape =SMeasrueArea.iShape;
                                    CRectangleGDIObject 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 ReadSEMDataFromSEM()
        {
          
           
            List<double> semParameters ;
           
         
            #region 获取电镜参数
            ////获取Field操作类对象
            if (m_SEMDATAFieldManage == null)
            {
                m_SEMDATAFieldManage = new SEMDATAFieldManage(m_MeasureAppForm.m_ProjParam);
            }
            //判断是否连接电镜
            if (m_SEMDATAFieldManage.InitAndConnection())
            {
                //获取电镜参数 放大倍数与工作距离 [Magnification]:放大倍数 [WorkingDistance]工作距离
                semParameters = m_SEMDATAFieldManage.GetSEMMagAndWDParameter();
                double mag = semParameters[0];
                double wd = semParameters[1];
                if (mag != 0 && wd != 0)
                {
                    //设置样品文件中的电镜参数 
                    m_MeasureAppForm.m_ProjParam.SetWorkingSampleSEMData(wd, mag);
             
                    //将右键SEM数据菜单设置为可编辑状态
                    CMStrip.Items[(int)MenuIndex.SetSemData].Enabled = true;
                    
                }

               
            }
           
            #endregion
          
           
        }
        #region 获取Filed帧图
        public List<CRectangleGDIObject> GetOTSFieldVisualRects(CVisualSampleArea sam, MSR_RUN_TYPE runType)
        {
            List<Point> listCenterPoint ;
            Size rectSize ;
           
            var m_ResultData = m_MeasureAppForm.m_ProjParam.GetResultData();
            var sample = m_ResultData.GetSampleByName(sam.GetSampleName());
            List<CRectangleGDIObject> visualfieldRects = new List<CRectangleGDIObject>();

            if (GetFieldData(sample,runType,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);

                    string ColorStr = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SingleColor);


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


                    CRectangleGDIObject createRect = new CRectangleGDIObject(visualRect, otsPoint.X, otsPoint.Y, CreateRectangleType.FieldRectangle, sampleHoleName, sampleName, ColorTranslator.FromHtml(ColorStr));

                    visualfieldRects.Add(createRect);
                }
            }
            return visualfieldRects;


        }
        public bool GetFieldData(COTSSample sample, MSR_RUN_TYPE runType ,out List<Point> pFields, out Size iSzie)
        {
             pFields = new List<Point>();
            iSzie = new Size();
         
            COTSSample WSample = sample;
            if (null == WSample)
            {
                return false;
            }
            
            CDomain pMsrArea = WSample.GetMsrArea();

         
            COTSImgScanPrm pImgScanParam = WSample.GetMsrParams().GetImageScanParam();

            COTSImageProcParam pImgProcParam = WSample.GetMsrParams().GetImageProcessParam();

            CFieldPositionMgr pFieldMgr = new CFieldPositionMgr();
            List<PointF> listPoint = new List<PointF>();
            listPoint.Clear();
            //设置测量区域
            CSEMDataMsr pSEMDataMsr; ;
            if (runType == MSR_RUN_TYPE.RUNSampleHoleImage)
            {
                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);

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

          

            var oValue = new Rectangle();
            if (!pFieldMgr.GetFieldRectByIndex(0, ref oValue))
            {
                return false;
            }
            iSzie = oValue.Size;
      

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

                List<CRectangleGDIObject> visualfieldRects = null;

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

                if (runType == MSR_RUN_TYPE.RUNSampleHoleImage)
                {
                    foreach (var r in visualfieldRects)
                    {
                        r.SetDisplayRefPoint(m_visualStage.GetDisplayRefPoint());
                        r.SetZoomNumber(m_visualStage.GetZoomNum());
                        m_ImageOfFieldGDIObjects.Add(r);
                    }
                   
                }
                else if (runType == MSR_RUN_TYPE.RUNMEASURE)
                {
                 
                    sam.GetMeasureGDIObject().SubItems().Clear();
                    //添加帧图列表
                    int sequenceNum=0;
                    for  (int i=0;i<visualfieldRects.Count;i++)
                    {
                        var r = visualfieldRects[i];
                        if (sam.GetMeasureGDIObject().ifRectangleIntersect(r))//filter the unmeasure fields
                        {
                            r.SequenceNum = sequenceNum++;
                            sam.AddFieldGDIObject(r);
                        }
                       
                    }

                    SaveFieldPositionInfoToSample(sam);
                    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 = fields[i];
                var otsPoint = new Point(f.OTSX, f.OTSY);
                sample.AddFieldData(otsPoint);
            }
         


        }
        #endregion

        #region 设置SEM数据
        public bool SetSEMDATAMParameter(double magnification, double semWorkingDistance)
        {
            #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);
                wFlag = m_SEMDATAFieldManage.SetSemWorkingDistance(semWorkingDistance);
                if (mFlag || wFlag)
                {
                    return true;
                }
             
            }
            return false;
            #endregion
        }

        public bool GetSEMDATAMParameter(ref double magnification, ref double WorkingDistance)
        {
            #region 获取电镜参数
            //获取Field操作类对象
            if (m_SEMDATAFieldManage == null)
            {
                m_SEMDATAFieldManage = new SEMDATAFieldManage(m_MeasureAppForm.m_ProjParam);
            }
            //判断是否连接电镜
            if (m_SEMDATAFieldManage.InitAndConnection())
            {
                //获取电镜参数
                List<double> semParameters = m_SEMDATAFieldManage.GetSEMMagAndWDParameter();
                //放大倍数
                magnification = semParameters[0];
                WorkingDistance = semParameters[1];
            
                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)));
                   
           
                    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)
        {
         
            CRectangleGDIObject itemWorkSample;
            var sam = GetWorkingVisualSample();

            itemWorkSample = GetWorkingVisualSample().GetSampleGDIObject();
            //获取样品孔BSE图像
            Image bseImage ;
            int m_iWidth = width;
            int m_iHeigh = height;
            RectangleF ImgRegionF;
            float ImgRegionWidth;
            float ImgRegionHeight ;
            if (m_ImageOfFieldGDIObjects.Count > 0)
            {
                for (int i = 0; i < m_ImageOfFieldGDIObjects.Count; i++)
                {
                   
                    var ctrlPos = m_visualStage.OTSCoordToCtrlCoord(fieldPos);
                    if (m_ImageOfFieldGDIObjects[i].IfContains(ctrlPos))
                    { 
                        ImgRegionF = m_ImageOfFieldGDIObjects[i].GetOrigionalDrawRegionF();
                        ImgRegionWidth = Convert.ToInt32(ImgRegionF.Width);
                        ImgRegionHeight = Convert.ToInt32(ImgRegionF.Height);

                        //获取图片
                        bseImage = CImageHandler.ToGrayBitmap(ImageData, m_iWidth, m_iHeigh);
                     
                        //绘制图像
                        CRectangleGDIObject createImageRect =new CRectangleGDIObject (ImgRegionF, fieldPos.X, fieldPos.Y, itemWorkSample.SampleName, itemWorkSample.NameOrHoleName, bseImage, ImgRegionWidth, ImgRegionHeight, CreateRectangleType.DrawSampleHoleBSEImage);
                        //添加至List集合中
                        createImageRect.SetInitRegionF(m_ImageOfFieldGDIObjects[i].GetOrigionalDrawRegionF());
                        createImageRect.NameOrHoleName = m_ImageOfFieldGDIObjects[i].NameOrHoleName;
                        createImageRect.SetZoomNumber(m_visualStage.GetZoomNum());
                        createImageRect.SetDisplayRefPoint(m_visualStage.GetDisplayRefPoint());
                        m_ImageGDIObjects.Add(createImageRect);
                       
                        break;
                    }
                }
            }
            //显示样品孔照片
            IsShowSampleHoleImage = true;
            Invalidate();
        }
        #endregion

        #region 删除样品孔中BSE图像信息
        public void DeleteHoleBSEImageData()
        {
            try
            {
                //鼠标右键点击的位置坐标
                Point mouseCurrent = m_MouseDownPoint;

                //样品名称
                string SampleName = "";
                //获取当前工作样品并删除对应BSE图
                foreach (CRectangleGDIObject ImageItem in m_ImageGDIObjects)
                {
                    if (ImageItem.IfZoomContains(mouseCurrent))
                    {
                        SampleName = ImageItem.SampleName;
                        break;
                    }
                }
                if (SampleName != null && !SampleName.Equals(""))
                {
                    string message = table["message7"].ToString();
                    if (MessageBox.Show(message, "Tip", MessageBoxButtons.YesNo, MessageBoxIcon.Information) == DialogResult.Yes)
                    {
                     
                        DeleteHoleBSEImageDataNoMessageBox();
                        return;
                    }
                    else
                    {
                        return;
                    }
                }

                //删除样品孔BSE图
                //样品孔名称
                string HoleName = "";
                var item = m_visualStage.GetHoleGDIByMousePoint(mouseCurrent);
              
                    if (item!=null)
                    {
                        HoleName = item.NameOrHoleName;
                        
                    }
               
                if (HoleName != null && !HoleName.Equals(""))
                {
                    string message = table["message8"].ToString();
                    if (MessageBox.Show(message, "Tip", MessageBoxButtons.YesNo, MessageBoxIcon.Information) == DialogResult.Yes)
                    {
                       
                        DeleteHoleBSEImageDataNoMessageBox();
                        return;
                    }
                    else
                    {
                        return;
                    }
                }
            }
            catch (Exception ex)
            {
               
                log.Trace(ex.ToString());
            }
        }
        public void DeleteHoleBSEImageDataNoMessageBox()
        {
           
                        //鼠标右键点击的位置坐标
                        Point mouseCurrent = m_MouseDownPoint;
                     
                        var item = m_visualStage.GetHoleGDIByMousePoint(mouseCurrent);
                        if (item!=null)
                        {
                            m_ImageOfFieldGDIObjects.Clear();
                            m_ImageGDIObjects.Clear();
                           Invalidate();

                        }
              
        }
        #endregion

        #region 获取样品孔图片
        private  int GetSampleHoleIndex(StageDrawingData oTSSampleStageData, string sampleHoleName, ref OTSSampleHoleInfo sampleHoleInfo)
        {
            try
            {
                int sampleHoleIndex = -1;
                if (oTSSampleStageData.sSHoleInfoList.Count > 0)
                {
                    for (int i = 0; i < oTSSampleStageData.sSHoleInfoList.Count; i++)
                    {
                        if (oTSSampleStageData.sSHoleInfoList[i].sSHoleName == sampleHoleName)
                        {
                            sampleHoleInfo = oTSSampleStageData.sSHoleInfoList[i];
                            sampleHoleIndex = i;
                            break;
                        }
                    }
                }
                return sampleHoleIndex;
            }
            catch (Exception)
            {
                return -1;
            }
        }
        public void GetBSEPictures()
        {
    
                    OTSSampleHoleInfo sampleHoleInfo = null;
                 var index=   GetSampleHoleIndex(m_visualStage.GetOTSSampleStageData(), m_SampleHoleSelectName, ref sampleHoleInfo);
                    if (sampleHoleInfo != null)
                    {
   
                            m_MeasureAppForm.StartSampleHoleBSEImage(index);
                     }
            
        }
        #endregion

        #region 复位工作样品区域
        public  CRectangleGDIObject ResetMeasure( CRectangleGDIObject SampleGDIObjects, CRectangleGDIObject MeasureGDIObjects)
        {
       
             
                 m_visualStage .GetMeasureGdiObjectFromSampleGdi(SampleGDIObjects,out MeasureGDIObjects);
              

                return MeasureGDIObjects;
           
        }
        public void ResetWorkSampleMeasure()
        {
            COTSSample WSample = m_MeasureAppForm.m_ProjParam.GetWorkSample();
            OTSSamplePropertyInfo MeasureInfo = new OTSSamplePropertyInfo();
            if (!m_MeasureAppForm.m_ProjParam.GetWorkSamplePerameter(WSample, ref MeasureInfo))
            {
                return;
            }
            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);
            CRectangleGDIObject m_MeasureGDIObject = m_visualStage.GetCtrlCoordRect(xHole,yHole,(CreateRectangleType)MeasureInfo.SMeasurePara.iShape, "", "");
            m_MeasureGDIObject.SetInitRegionF(SampleRectangleF);
     
            var sam = GetWorkingVisualSample();
            var mea = sam.GetMeasureGDIObject();
            CRectangleGDIObject m_ResetMeasureGDIobjects = ResetMeasure( sam.GetSampleGDIObject(), m_MeasureGDIObject);
            mea.SetInitRegionF(m_ResetMeasureGDIobjects.GetOrigionalDrawRegionF());
            mea.Shape = m_ResetMeasureGDIobjects.Shape;
            Invalidate();
               
        }
        #endregion

    }
}
#endregion