OTS/OTSIncAMeasureApp/4-OTSSamplespaceGraphicsPanel/CreateRectangle.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

namespace OTSMeasureApp
{
    

    public class CRectangleGDIObject /*: CRectangleGDIObject */// 同样的方式可以从ADraggableGDIObject生成其它图形的继承角类，比如矩形，三形等等。。
    {
        public CRectangleGDIObject()
        {
       
            ID = System.Guid.NewGuid().ToString();
            OTSX = -1;
            OTSY = -1;
        }
        /// <summary>
        /// 创建图形
        /// </summary>
        /// <param name="startx">X位置</param>
        /// <param name="starty">Y位置</param>
        /// <param name="width">宽度</param>
        /// <param name="height">高度</param>
        /// <param name="cType">图形类型：createType=0 圆角矩形 createType=1 圆形 createType=2 文字</param>
        /// <param name="content">文字内容</param>
        public CRectangleGDIObject(float startx, float starty, float width, float height, CreateRectangleType cType, string content, string name)
        {
            var rec = new RectangleF(startx, starty, width, height);
            m_OrigineRegionF = rec;
            SetInitRegionF(m_OrigineRegionF);
            CreateType = cType;
            strContent = content;
            NameOrHoleName = name;
            ID = System.Guid.NewGuid().ToString();
            OTSX = -1;
            OTSY = -1;
        }

        public CRectangleGDIObject(RectangleF rect, CreateRectangleType cType)
        {
       
            m_OrigineRegionF = rect;
            SetInitRegionF(m_OrigineRegionF);
            CreateType = cType;
            ID = System.Guid.NewGuid().ToString();
            //startPoint = new PointF(rect.Left, rect.Top);
            //EndPoint = new PointF(rect.Right, rect.Bottom);
            OTSX = -1;
            OTSY = -1;
        }
        public CRectangleGDIObject(RectangleF rect, CreateRectangleType cType, string name)
        {
     
            m_OrigineRegionF = rect;
            SetInitRegionF(m_OrigineRegionF);
            CreateType = cType;
            NameOrHoleName = name;
            ID = System.Guid.NewGuid().ToString();
            OTSX = -1;
            OTSY = -1;
        }
 
        public CRectangleGDIObject(RectangleF rect, CreateRectangleType cType, ShapeType shape, string name, Color selColor)
        {
          
            m_OrigineRegionF = rect;
            SetInitRegionF(m_OrigineRegionF);
            CreateType = cType;
            NameOrHoleName = name;
            Shape = shape;
            SelColor = selColor;
            ID = System.Guid.NewGuid().ToString();
            OTSX = -1;
            OTSY = -1;
        }
        public CRectangleGDIObject(RectangleF rectMeasure,  CreateRectangleType cType, ShapeType shape, string name, string sampleName, Color selColor)
        {
      
            m_OrigineRegionF = rectMeasure;
            SetInitRegionF(m_OrigineRegionF);
            CreateType = cType;
            NameOrHoleName = name;
            Shape = shape;
            SelColor = selColor;
          
            SampleName = sampleName;
            ID = System.Guid.NewGuid().ToString();
            OTSX = -1;
            OTSY = -1;
        }
        //绘制帧图
        public CRectangleGDIObject(RectangleF rectSingle, CreateRectangleType cType, string name, string sampleName, Color selColor)
        {
          
            m_OrigineRegionF = rectSingle;
            SetInitRegionF(m_OrigineRegionF);
            CreateType = cType;
            NameOrHoleName = name;
            Shape = 0;
            SelColor = selColor;
            SampleName = sampleName;
            ID = System.Guid.NewGuid().ToString();
            OTSX = -1;
            OTSY = -1;
        }
        //绘制帧图
        public CRectangleGDIObject(RectangleF rectField, int OTSx, int OTSy, CreateRectangleType cType, string name, string sampleName, Color selColor)
        {
         
            m_OrigineRegionF = rectField;
            SetInitRegionF(m_OrigineRegionF);
            CreateType = cType;
            NameOrHoleName = name;
            Shape = 0;
            SelColor = selColor;
            SampleName = sampleName;
            ID = System.Guid.NewGuid().ToString();
            OTSX = OTSx;
            OTSY = OTSy;
        }

        /// <summary>
        /// 获取样品孔中BSE图像
        /// </summary>
        /// <param name="rect">位置大小</param>
        /// <param name="sampleHoleName">所在样品孔名称</param>
        /// <param name="bseImage">图像信息</param>
        /// <param name="bseImageWitdh">图像宽度</param>
        /// <param name="bseImageHeight">图像高度</param>
        /// <param name="drawImageLocation">图像开始位置</param>
        /// <param name="cType">绘制类型</param>
        public CRectangleGDIObject(RectangleF rect, int OTSx, int OTSy, string sampleName, string sampleHoleName,  float bseImageWitdh, float bseImageHeight, CreateRectangleType cType)
        {
         
            m_OrigineRegionF = rect;
            SetInitRegionF(m_OrigineRegionF);
            NameOrHoleName = sampleHoleName;
            SampleName = sampleName;
            //生成编号
            ID = System.Guid.NewGuid().ToString();
            //图像信息
            //BSEImage = bseImage;
            //图像宽度
            BSEImageWitdh = bseImageWitdh;
            //图像高度
            BSEImageHeight = bseImageHeight;
            //图像位置
            BSEImageLocation = rect.Location;
            OTSX = OTSx;
            OTSY = OTSy;
            //绘制类型
            CreateType = cType;
        }


        public CRectangleGDIObject(RectangleF rect, Point ImgPoint, float m_Multiple, CreateRectangleType cType)
        {

            m_OrigineRegionF = rect;
            SetInitRegionF(m_OrigineRegionF);
            CreateType = cType;
            ID = System.Guid.NewGuid().ToString();
  
            OTSX = -1;
            OTSY = -1;
        }
        /// <summary>
        /// 获取多边形点集合
        /// </summary>
        /// <param name="mPoint"></param>
        /// <param name="cType"></param>
        public CRectangleGDIObject(List<PointF> mPoint, CreateRectangleType cType, ShapeType shape, string name, string sampleName, Color selColor)
        {
            ID = System.Guid.NewGuid().ToString();

            this.SetOriginalPolygonPointFList(mPoint);


            NameOrHoleName = name;
            SampleName = sampleName;
            CreateType = cType;
            Shape = shape;
            SelColor = selColor;


         


        }
        #region 变量重写
        public virtual  void OnPaint(PaintEventArgs e) 
        {
            if (createType == CreateRectangleType.SampleBackGround_Rectangle)
            {
                //获取颜色
                Color myColor = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.RoundRectangleColor);
                
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                GraphicsPath grPath = CreateRoundedRectanglePath(m_RegionF, 20);
                e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
                e.Graphics.FillPath(sampleBrush, grPath);
                e.Graphics.DrawPath(Pens.Black, grPath);
            }
            //样品台-圆形
            else if (createType == CreateRectangleType.SampleBackGround_Circle)
            {
                //获取颜色
                Color myColor = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.SampleBackGroundColor);
                
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点
                e.Graphics.FillEllipse(sampleBrush, m_RegionF);
                e.Graphics.DrawEllipse(Pens.Black, m_RegionF);
            }
            //圆形
            else if (createType == CreateRectangleType.Circle)
            {
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(System.Drawing.Color.White);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点
                e.Graphics.FillEllipse(sampleBrush, m_RegionF);
                e.Graphics.DrawEllipse(Pens.Black, m_RegionF);
            }
            //文字
            else if (createType == CreateRectangleType.Text)
            {
                //设置文字对齐方式
                StringFormat sf = new StringFormat();
                sf.Alignment = StringAlignment.Center;
                sf.LineAlignment = StringAlignment.Center;
                //文字颜色
                Color myColor = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.FontColor);
                
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                SolidBrush solidBrush = new SolidBrush(Color.FromArgb(50, Color.Black));
                //字体大小 根据样品孔Rectangle大小
                float fontSize = m_RegionF.Width / 2;
                Font font = new Font("宋体", fontSize, FontStyle.Regular);
                if (fontSize == 0)
                {
                    font = new Font("宋体", 5, FontStyle.Regular);
                }
                //消除锯齿
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点
               
                e.Graphics.DrawString(strContent, font, sampleBrush, m_RegionF, sf);
            }
            //矩形
            else if (createType == CreateRectangleType.Rectangle)
            {
                Color myColor = System.Drawing.Color.White;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点
                e.Graphics.FillRectangle(sampleBrush, m_RegionF);
                var m_Region = new Rectangle();
                m_Region.X = (int)m_RegionF.X;
                m_Region.Y = (int)m_RegionF.Y;
                m_Region.Width = (int)m_RegionF.Width;
                m_Region.Height = (int)m_RegionF.Height;
                e.Graphics.DrawRectangle(Pens.Black, m_Region);
            }
            //选择样品台
            else if (createType == CreateRectangleType.SelectSample)
            {
                Color myColor = selColor;

                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.AssumeLinear;//再加一点
                if (Shape == 0)
                {

                    e.Graphics.FillEllipse(sampleBrush, m_RegionF);
                    e.Graphics.DrawEllipse(Pens.Black, m_RegionF);
                }
                else
                {
                    e.Graphics.FillRectangle(sampleBrush, m_RegionF);
                    var m_Region = new Rectangle();
                    m_Region.X = (int)m_RegionF.X;
                    m_Region.Y = (int)m_RegionF.Y;
                    m_Region.Width = (int)m_RegionF.Width;
                    m_Region.Height = (int)m_RegionF.Height;
                    e.Graphics.DrawRectangle(Pens.Black, m_Region);
                }
            }
            //测试区域
            else if (createType == CreateRectangleType.MeasureArea)
            {
                Color myColor = selColor;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                Pen p = new Pen(myColor, 1);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点


                if (Shape == 0)
                {

                    e.Graphics.DrawEllipse(p, m_RegionF);
                }
                else
                {
                    var m_Region = new Rectangle();
                    m_Region.X = (int)m_RegionF.X;
                    m_Region.Y = (int)m_RegionF.Y;
                    m_Region.Width = (int)m_RegionF.Width;
                    m_Region.Height = (int)m_RegionF.Height;

                    e.Graphics.DrawRectangle(p, m_Region);

                }
            }
            //绘制帧图 直线
            else if (createType == CreateRectangleType.SingleLine)
            {
                //设置颜色
                Color myColor = OTSSamplespaceGraphicsPanelFun.GetColorValue(ColorType.FieldColor);
             
                //设置画笔
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                Pen pen = new Pen(sampleBrush, 0.0001f);
                //未抗锯齿
                e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.Default;
                e.Graphics.InterpolationMode = InterpolationMode.Default;
                e.Graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
                //设置直线位置与尺寸
                PointF startPointF = new PointF(startPoint.X, startPoint.Y);
                PointF endPointF = new PointF(endPoint.X, endPoint.Y);
                //度量单位
                e.Graphics.PageUnit = GraphicsUnit.Display;
                e.Graphics.DrawLine(pen, startPointF, endPointF);

            }
            //绘制标样
            else if (createType == CreateRectangleType.SpecimenRectangle)
            {
                Color myColor = System.Drawing.Color.Black;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                Pen pen = new Pen(sampleBrush, 0.0001f);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
                var m_Region = new Rectangle();
                m_Region.X = (int)m_RegionF.X;
                m_Region.Y = (int)m_RegionF.Y;
                m_Region.Width = (int)m_RegionF.Width;
                m_Region.Height = (int)m_RegionF.Height;
                e.Graphics.DrawRectangle(pen, m_Region);
                e.Graphics.FillRectangle(sampleBrush, m_Region);
            }
            //绘制标样
            else if (createType == CreateRectangleType.SpecimenCircle)
            {
                Color myColor = System.Drawing.Color.Black;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                Pen pen = new Pen(sampleBrush, 0.0001f);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
                e.Graphics.DrawEllipse(pen, m_RegionF);
                e.Graphics.FillEllipse(sampleBrush, m_RegionF);
            }
            //绘制帧图
            else if (createType == CreateRectangleType.FieldRectangle)
            {
                Color myColor = SelColor;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                Pen pen = new Pen(sampleBrush, 0.01f);
                e.Graphics.SmoothingMode = SmoothingMode.Default;
                //设置直线位置与尺寸
                PointF startPointF = new PointF(m_RegionF.Left, m_RegionF.Top);
                PointF endPointF = new PointF(m_RegionF.Right, m_RegionF.Bottom);

                float fontSize = m_RegionF.Width / 4;
                Font font;
                if (fontSize == 0)
                {
                    font = new Font("宋体", 5, FontStyle.Regular);
                }
                else
                {
                    font = new Font("宋体", fontSize, FontStyle.Regular);
                }
               
                StringFormat sf = new StringFormat();
                sf.Alignment = StringAlignment.Center;
                sf.LineAlignment = StringAlignment.Center;
                e.Graphics.DrawString(m_sequenceNum.ToString(), font, sampleBrush, m_RegionF, sf);


                //绘制帧图
                e.Graphics.DrawRectangle(pen, startPointF.X, startPointF.Y, endPointF.X - startPointF.X, endPointF.Y - startPointF.Y);
            }
            //绘制颗粒
            else if (createType == CreateRectangleType.ParticleLine)
            {
                Color myColor = LineColor;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                Pen pen = new Pen(sampleBrush, 0.01f);
                e.Graphics.SmoothingMode = SmoothingMode.Default;
                //设置直线位置与长度
                PointF startPointF = LineStartPoint;
                float length = LineLength;
                PointF endPointF = new PointF(startPointF.X + length, startPointF.Y);
                e.Graphics.DrawLine(pen, startPointF, endPointF);
            }
            //矩形
            else if (createType == CreateRectangleType.ParticleAreaRectangle)
            {
                Color myColor = System.Drawing.Color.White;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点
                var m_Region = new Rectangle();
                m_Region.X = (int)m_RegionF.X;
                m_Region.Y = (int)m_RegionF.Y;
                m_Region.Width = (int)m_RegionF.Width;
                m_Region.Height = (int)m_RegionF.Height;
                e.Graphics.DrawRectangle(Pens.Black, m_Region);
            }
            //绘制样品孔BSE图像
            else if (createType == CreateRectangleType.DrawFrameOfHoleBSEImage)
            {
                Color myColor = System.Drawing.Color.White;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点

                //设置直线位置与尺寸
                PointF startPointF = new PointF(m_RegionF.Left, m_RegionF.Top);
                PointF endPointF = new PointF(m_RegionF.Right + 2, m_RegionF.Bottom + 2);
                //绘制样品孔中图像信息
                if (BSEImage != null)
                {
                    e.Graphics.DrawImage(BSEImage, startPointF.X, startPointF.Y, endPointF.X - startPointF.X, endPointF.Y - startPointF.Y);

                }
            }
            else if (createType == CreateRectangleType.DrawSEMCenterPoint)
            {
                Color myColor = System.Drawing.Color.Red;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点
                //X轴线
                PointF startPointX = semCenterPoint;
                startPointX.X = startPointX.X - 3;
                PointF endPointX = semCenterPoint;
                endPointX.X = endPointX.X + 3;
                //Y轴线
                PointF startPointY = semCenterPoint;
                startPointY.Y = startPointY.Y - 3;
                PointF endPointY = semCenterPoint;
                endPointY.Y = endPointY.Y + 3;
                //绘制XY轴交叉线+ 
                Pen pen = new Pen(sampleBrush, 0.0001f);
                e.Graphics.DrawLine(pen, startPointX, endPointX);
                e.Graphics.DrawLine(pen, startPointY, endPointY);
            }
            //绘制BSE标记
            else if (createType == CreateRectangleType.DrawBSEElementSignPoint)
            {
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(System.Drawing.Color.Green);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点
                Pen pen = new Pen(sampleBrush, 2f);
                int X = (int)m_OrigineRegionF.X;
                int Y = (int)m_OrigineRegionF.Y;
                e.Graphics.DrawLine(pen, new Point(X - 8, Y), new Point(X + 8, Y));
                e.Graphics.DrawLine(pen, new Point(X, Y - 8), new Point(X, Y + 8));
            }
            //绘制多边形测量区域
            else if (createType == CreateRectangleType.Polygon)
            {
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点
                Color myColor = selColor;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                Pen pen = new Pen(myColor, 1);
                if (GetPolygonPointFList().Count > 0)
                {
                    List<PointF> PolygonPointF = new List<PointF>();
                    foreach (var item in m_PolygonPoints)
                    {
                        PolygonPointF.Add(item);
                    }
                    if (PolygonDrawingEndPoint.X != 0 && PolygonDrawingEndPoint.Y != 0)
                    {
                        PolygonPointF.Add(PolygonDrawingEndPoint);
                    }

                    e.Graphics.DrawLines(pen, PolygonPointF.ToArray());
                    

                }
            }//多边形测量区域完成标识
            else if (createType == CreateRectangleType.DrawPolygonFinish)
            {
                Color myColor = selColor;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点
                Pen pen = new Pen(myColor, 1);
                var m_Region = new Rectangle();
                m_Region.X = (int)m_RegionF.X;
                m_Region.Y = (int)m_RegionF.Y;
                m_Region.Width = (int)m_RegionF.Width;
                m_Region.Height = (int)m_RegionF.Height;
                e.Graphics.DrawRectangle(pen, m_Region);
            }
            //绘制多边形测量区域
            else if (createType == CreateRectangleType.CircleByThreePoints)
            {
                Color myColor = selColor;
                System.Drawing.SolidBrush sampleBrush = new System.Drawing.SolidBrush(myColor);
                Pen p = new Pen(myColor, 1);
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;  //图片柔顺模式选择
                e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;//高质量
                e.Graphics.CompositingQuality = CompositingQuality.HighQuality;//再加一点

                var m_Region = new Rectangle();
                m_Region.X = (int)m_RegionF.X;
                m_Region.Y = (int)m_RegionF.Y;
                m_Region.Width = (int)m_RegionF.Width;
                m_Region.Height = (int)m_RegionF.Height;
                e.Graphics.DrawEllipse(p, m_Region);

            }
        }
        public  Image BSEImage
        {
            get { return bseImage; }
            set { bseImage = value; }
        }
        public  float BSEImageWitdh
        {
            get { return bseImageWidth; }
            set { bseImageWidth = value; }
        }
        public  float BSEImageHeight
        {
            get { return bseImageHeight; }
            set { bseImageHeight = value; }
        }
        public  PointF BSEImageLocation
        {
            get { return bseImageLocation; }
            set { bseImageLocation = value; }
        }
        public  Color LineColor
        {
            get { return lineColor; }
            set { lineColor = value; }
        }
        public  float LineLength
        {
            get { return lineLength; }
            set { lineLength = value; }
        }
        public  PointF LineStartPoint
        {
            get { return lineStartPoint; }
            set { lineStartPoint = value; }
        }
    
        public  int OTSX
        {
            get { return otsX; }
            set { otsX = value; }
        }
        public  int OTSY
        {
            get { return otsY; }
            set { otsY = value; }
        }
        public  CreateRectangleType CreateType
        {
            get { return createType; }
            set { createType = value; }
        }
        public  ShapeType Shape
        {
            get { return shape; }
            set { shape = value; }
        }
        public  Color SelColor
        {
            get { return selColor; }
            set { selColor = value; }
        }
        public  string NameOrHoleName//holename when they are not field rectangle gdi object.
        {
            get { return nameOrHoleName; }
            set { nameOrHoleName = value; }
        }
        public  string ID
        {
            get { return id; }
            set { id = value; }
        }
        public  string SampleName
        {
            get { return sampleName; }
            set { sampleName = value; }
        }
        public  int SampleCount
        {
            get { return sampleCount; }
            set { sampleCount = value; }
        }
        public string StrContent
        {
            get { return strContent; }
            set { strContent = value; }
        }
        public  RectangleF GetZoomedRegion
        {
            
            get {
                var m_Region = new RectangleF();
                m_Region.X = m_RegionF.X;
                m_Region.Y = m_RegionF.Y;
                m_Region.Width = m_RegionF.Width;
                m_Region.Height = m_RegionF.Height;
                   return m_Region;          
                }
           
        }
        public List<PointF> GetVertexPoints()
        {
            List<PointF> vertexPoint = new List<PointF>();
            var region = this.GetZoomedRegionF();
            vertexPoint.Add(region.Location);
            vertexPoint.Add(new PointF(region.X, region.Y + region.Height));
            vertexPoint.Add(new PointF(region.X + region.Width, region.Y));
            vertexPoint.Add(new PointF(region.X + region.Width, region.Y + region.Height));
            return vertexPoint;
        }

        public  RectangleF GetZoomedRegionF()
        { 
            return m_RegionF; 
        }
        public  void SetInitRegionF(RectangleF OrigineRegionF)//not zoomed regine value
        {
            

            float x1, y1;
            x1 = OrigineRegionF.X * m_zoomNum + m_refPoint.X;
            y1 = OrigineRegionF.Y * m_zoomNum + m_refPoint.Y;

            float w1, h1;
            w1 = OrigineRegionF.Width * m_zoomNum;
            h1 = OrigineRegionF.Height * m_zoomNum;



            m_OrigineRegionF = OrigineRegionF;

            m_RegionF = new RectangleF(x1, y1, w1, h1);



        }
        internal void SetZoomedRegionF(RectangleF scaleRectangleF)
        {
            float x1, y1;
            x1 = (scaleRectangleF.X-m_refPoint.X) / m_zoomNum ;
            y1 = (scaleRectangleF.Y-m_refPoint.Y) / m_zoomNum ;

            float w1, h1;
            w1 = scaleRectangleF.Width / m_zoomNum;
            h1 = scaleRectangleF.Height / m_zoomNum;


            m_OrigineRegionF =  new RectangleF(x1, y1, w1, h1);

            m_RegionF = scaleRectangleF;

        }
        private  Rectangle GetMinRectangleOfPolygon(List<PointF> polygonPointList)
        {
            if (polygonPointList != null)
            {
                if (polygonPointList.Count > 0)
                {
                    int pCount = polygonPointList.Count;
                    float minX = polygonPointList[0].X;
                    float minY = polygonPointList[0].Y;
                    float maxX = polygonPointList[0].X;
                    float maxY = polygonPointList[0].Y;
                    //获取最小X,Y 最大X,Y
                    for (int i = 0; i < pCount; i++)
                    {
                        minX = Math.Min(minX, polygonPointList[i].X);
                        minY = Math.Min(minY, polygonPointList[i].Y);
                        maxX = Math.Max(maxX, polygonPointList[i].X);
                        maxY = Math.Max(maxY, polygonPointList[i].Y);
                    }

                    //创建外接矩形
                    Rectangle rect = new Rectangle();
                    rect.Location = new Point((int)minX, (int)minY);
                    rect.Size = new Size((int)maxX - (int)minX, (int)maxY - (int)minY);
                    return rect;
                }
            }
            return new Rectangle();
        }

        public RectangleF GetOrigionalDrawRegionF()
        { return m_OrigineRegionF; }


        public List<PointF> GetOriginalPolygonPointFList()
        { return m_originalPolygonPoints; }
        public void SetOriginalPolygonPointFList(List<PointF> value)
        {
            if (m_zoomNum != 1)
            {
                var ps = new List<PointF>();
                foreach (var p in value)
                {
                    var p1 = new PointF();

                    p1.X = p.X * m_zoomNum+m_refPoint.X;
                    p1.Y = p.Y  *m_zoomNum+ m_refPoint.Y;
                    ps.Add(p1);

                }


               
                m_PolygonPoints = ps;
                m_originalPolygonPoints = value;
            }
            else 
            {
                m_originalPolygonPoints = value;
                m_PolygonPoints = value;
            }
           

        }

        public List<PointF> GetPolygonPointFList()
        { return m_PolygonPoints; }
        public void SetPolygonPointFList(List<PointF> value)
        {
            if (m_zoomNum != 1)
            {
                var ps = new List<PointF>();
                foreach (var p in value)
                {
                    var p1 = new PointF();

                    p1.X = (p.X - m_refPoint.X) / m_zoomNum;
                    p1.Y = (p.Y - m_refPoint.Y) / m_zoomNum;
                    ps.Add(p1);

                }


                m_originalPolygonPoints = ps;
                m_PolygonPoints = value;
            }
            else
            {
                m_originalPolygonPoints = value;
                m_PolygonPoints = value;
            }


            var region = GetMinRectangleOfPolygon(m_PolygonPoints);
            SetZoomedRegionF(region);

        }

        public GraphicsPath GetGPath()
        {

            var measureItem = this;
            //重新绘制测量区域路径
            GraphicsPath GPath = new GraphicsPath();
        
            if (measureItem.CreateType == CreateRectangleType.Polygon)
            {
                GraphicsPath PolygonMeasurePath = new GraphicsPath();
                PolygonMeasurePath.AddPolygon(measureItem.GetPolygonPointFList().ToArray());
                GPath = PolygonMeasurePath;
            }
            else if (measureItem.CreateType == CreateRectangleType.CircleByThreePoints)
            {
                GPath.AddEllipse(GetZoomedRegionF());
            }
            else
            {
                if (measureItem.Shape == (int)CreateRectangleType.Circle)
                {
                    GPath.AddEllipse(GetZoomedRegionF());
                }
                else
                {
                    GPath.AddRectangle(GetZoomedRegionF());
                }
            }
          
            return GPath;

        }

        public  PointF PolygonDrawingEndPoint
        {
            get { return endPoint; }
            set { endPoint = value; }
        }
  

        public  Point GetZoomedCenterPoint()
        {
            Point pCenterPoint = new Point();
            //获取在工作窗口中X,Y位置
            pCenterPoint.X = (int)(this.GetZoomedRegion.X + this.GetZoomedRegion.Width / 2);
            pCenterPoint.Y = (int)(this.GetZoomedRegion.Y + this.GetZoomedRegion.Height / 2);
            return pCenterPoint;
        }

        public PointF GetCenterPoint()
        {
            PointF pCenterPoint = new PointF();
            //获取在工作窗口中X,Y位置
            pCenterPoint.X = (this.GetOrigionalDrawRegionF().X + this.GetOrigionalDrawRegionF().Width / 2);
            pCenterPoint.Y = (this.GetOrigionalDrawRegionF().Y + this.GetOrigionalDrawRegionF().Height / 2);
            return pCenterPoint;
        }
        #endregion


       
        public  bool IsDragging
        {
            get { return m_IsDragging; }
            set { m_IsDragging = value; }
        }
        public bool IsAltering// changing the size by gui operating.
        {
            get { return m_IsAlter; }
            set { m_IsAlter = value; }
        }

        public  bool IsWorkSample
        {
            get { return m_IsWorkSample; }
            set { m_IsWorkSample = value; }
        }
        public  PointF DraggingPoint
        {
            get { return m_DraggingPoint; }
            set {
                
                    m_DraggingPoint = value;
                    if (subItems.Count != 0)
                    {
                        foreach (var item in subItems)
                        {
                            item.DraggingPoint = m_DraggingPoint;
                        }
                
                    }
                }
        }

        public int SequenceNum { get => m_sequenceNum; set => m_sequenceNum = value; }
        public bool IsMoving { get => m_IsMoving; set => m_IsMoving = value; }

        public PointF GetDisplayRefPoint()
        { return m_refPoint; }

        public void SetDisplayRefPoint(PointF value)
        { 
            m_refPoint = value;
            SetInitRegionF(m_OrigineRegionF);
            if (m_originalPolygonPoints.Count != 0)
            {
                this.SetPolygonPointFList(m_originalPolygonPoints);
            }
        }

        public float GetZoomNumber()
        { return m_zoomNum; }


        public void SetZoomNumber(float value)
        { 
            m_zoomNum = value;
            SetInitRegionF(m_OrigineRegionF);
            if (m_originalPolygonPoints.Count != 0)
            {
                this.SetPolygonPointFList(m_originalPolygonPoints);
            }
        }





        #region 画圆角矩形
        internal static GraphicsPath CreateRoundedRectanglePath(RectangleF rect, int cornerRadius)
        {
            GraphicsPath roundedRect = new GraphicsPath();
            roundedRect.AddArc(rect.X, rect.Y, cornerRadius * 2, cornerRadius * 2, 180, 90);
            roundedRect.AddLine(rect.X + cornerRadius, rect.Y, rect.Right - cornerRadius * 2, rect.Y);
            roundedRect.AddArc(rect.X + rect.Width - cornerRadius * 2, rect.Y, cornerRadius * 2, cornerRadius * 2, 270, 90);
            roundedRect.AddLine(rect.Right, rect.Y + cornerRadius * 2, rect.Right, rect.Y + rect.Height - cornerRadius * 2);
            roundedRect.AddArc(rect.X + rect.Width - cornerRadius * 2, rect.Y + rect.Height - cornerRadius * 2, cornerRadius * 2, cornerRadius * 2, 0, 90);
            roundedRect.AddLine(rect.Right - cornerRadius * 2, rect.Bottom, rect.X + cornerRadius * 2, rect.Bottom);
            roundedRect.AddArc(rect.X, rect.Bottom - cornerRadius * 2, cornerRadius * 2, cornerRadius * 2, 90, 90);
            roundedRect.AddLine(rect.X, rect.Bottom - cornerRadius * 2, rect.X, rect.Y + cornerRadius * 2);
            roundedRect.CloseFigure();
            return roundedRect;
        }

        public  bool IfZoomContains(Point mousePoint)
        {
            if (mousePoint.X > m_RegionF.Left && mousePoint.X < m_RegionF.Left + m_RegionF.Width)
            {
                if (mousePoint.Y > m_RegionF.Top && mousePoint.Y < m_RegionF.Top + m_RegionF.Height)
                {
                    return true;
                
                }
            
            
            }
            return false;
        }
        public bool IfContains(PointF thePoint)
        {
            if (thePoint.X > m_OrigineRegionF.Left && thePoint.X < m_OrigineRegionF.Left + m_OrigineRegionF.Width)
            {
                if (thePoint.Y > m_OrigineRegionF.Top && thePoint.Y < m_OrigineRegionF.Top + m_OrigineRegionF.Height)
                {
                    return true;

                }


            }
            return false;
        }

        public  List<CRectangleGDIObject> SubItems()
        {
            if (subItems == null) subItems = new List<CRectangleGDIObject>();
            return subItems;
        }
        public void AddSubItems(CRectangleGDIObject item)
        {
            if (subItems == null) subItems = new List<CRectangleGDIObject>();
            subItems.Add(item);
        }
        public void ClearSubItems()
        {
            subItems.Clear();
        }

        public  void Zoom(PointF mousePoint, float zoomNum)

        {
            float X1;
            float curZoom = m_zoomNum;
            float deltaZoom = zoomNum - curZoom;
            float Y1;
            if (zoomNum == 1)
            {
                m_zoomNum = 1;
                m_RegionF = m_OrigineRegionF;
                m_refPoint = new PointF(0, 0);
                m_PolygonPoints = m_originalPolygonPoints;
            }
            else 
            {
              

                X1 = (m_RegionF.X - mousePoint.X) / curZoom * deltaZoom + m_RegionF.X;
                Y1 = (m_RegionF.Y - mousePoint.Y) / curZoom * deltaZoom + m_RegionF.Y;

                m_refPoint.X = (m_refPoint.X - mousePoint.X) / curZoom * deltaZoom + m_refPoint.X;
                m_refPoint.Y = (m_refPoint.Y - mousePoint.Y) / curZoom * deltaZoom + m_refPoint.Y;

                float Width = GetOrigionalDrawRegionF().Width * zoomNum;
                float Height = GetOrigionalDrawRegionF().Height * zoomNum;
                m_RegionF = new RectangleF(X1, Y1, Width, Height);
                m_zoomNum = zoomNum;


            } 
           
           


            BSEImageWitdh = m_RegionF.Width;
            BSEImageHeight = m_RegionF.Height;
            BSEImageLocation = m_RegionF.Location;
          

            var scalePs = new List<PointF>();
            foreach (var p in m_PolygonPoints)
            {
                float x, y;
                x = (p.X - mousePoint.X) / curZoom * deltaZoom + p.X;
                y = (p.Y - mousePoint.Y) / curZoom * deltaZoom + p.Y;
              
                scalePs.Add(new PointF(x, y));


            }
            m_PolygonPoints = scalePs;

        
            if (this.subItems.Count != 0)
            {
                foreach (var g in subItems)
                {
                    g.Zoom(mousePoint,zoomNum);
                }


            }
        }
        

        public  void Move(PointF location)
        {
            
            PointF offset = new PointF(location.X - DraggingPoint.X, location.Y - DraggingPoint.Y);
            float X1;
            float Y1;

            X1 = (m_RegionF.X + offset.X);
            Y1 = (m_RegionF.Y + offset.Y);


            m_RegionF = new RectangleF(X1, Y1, m_RegionF.Width, m_RegionF.Height);
        

            m_refPoint.X = m_refPoint.X + offset.X;
            m_refPoint.Y = m_refPoint.Y + offset.Y;

            BSEImageWitdh = m_RegionF.Width;
            BSEImageHeight = m_RegionF.Height;
            BSEImageLocation = m_RegionF.Location;
            //SEMCenterPoint = m_RegionF.Location;
            LineStartPoint = m_RegionF.Location;

            m_DraggingPoint = new Point((int)location.X,(int)location.Y);

            var scalePs = new List<PointF>();
            foreach (var p in m_PolygonPoints)
            {
                float x, y;
                x = (p.X + offset.X);
                y = (p.Y + offset.Y);

                scalePs.Add(new PointF(x, y));


            }
            m_PolygonPoints = scalePs;
          
            if (this.subItems.Count != 0)
            {
                foreach (var g in subItems)
                {
                    g.Move(location);
                }
            
            
            }
        }
        public void PositionAltering(PointF location,bool ifZoomCoord)
        {

            PointF offset = new PointF(location.X - DraggingPoint.X, location.Y - DraggingPoint.Y);

            PointF realShift;
            if (ifZoomCoord)
            {
                realShift = new PointF(offset.X / m_zoomNum, offset.Y / m_zoomNum);
            }
            else
            {
                realShift = new PointF(offset.X , offset.Y );
            }
           

  
            m_OrigineRegionF = new RectangleF(m_OrigineRegionF.X+realShift.X, m_OrigineRegionF.Y+realShift.Y, m_OrigineRegionF.Width, m_OrigineRegionF.Height);

            SetInitRegionF(m_OrigineRegionF);

            BSEImageWitdh = m_RegionF.Width;
            BSEImageHeight = m_RegionF.Height;
            BSEImageLocation = m_RegionF.Location;
          
            LineStartPoint = m_RegionF.Location;

            

            var scalePs = new List<PointF>();
            var OriginalPs = new List<PointF>();
            foreach (var p in m_PolygonPoints)
            {
                float x, y;
                x = (p.X + offset.X);
                y = (p.Y + offset.Y);
                scalePs.Add(new PointF(x, y));
             


            }
            m_PolygonPoints = scalePs;

            foreach (var p in m_originalPolygonPoints)
            {
             
                OriginalPs.Add(new PointF(p.X + realShift.X, p.Y + realShift.Y));

            }
            m_originalPolygonPoints = OriginalPs;

            m_DraggingPoint = new Point((int)location.X, (int)location.Y);

            if (this.subItems.Count != 0)
            {
                foreach (var g in subItems)
                {
                    g.PositionAltering(location,ifZoomCoord);
                }


            }
        }

        public  CRectangleGDIObject Duplicate(CreateRectangleType newType)
        {
            CRectangleGDIObject r = new CRectangleGDIObject();
            r.NameOrHoleName = this.nameOrHoleName;
            r.SampleName = this.SampleName;
            r.m_OrigineRegionF = this.m_OrigineRegionF;
        
            r.IsWorkSample = this.IsWorkSample;          
            r.m_RegionF = this.m_RegionF;
       

            r.m_refPoint = this.m_refPoint;
            r.m_zoomNum = this.m_zoomNum;
         
            r.shape = this.shape;

            r.createType = newType;
            
            return r;
        }
       virtual public bool ifRectangleIntersect(CRectangleGDIObject othergdi)
        {
            return true;
        }

        #endregion
        //是否设置为选择样品
        private bool m_IsAlter;
        //是否存在帧图信息
      
        //是否设置为拖动
        private bool m_IsDragging;

        private bool m_IsMoving;
        //是否为工作样品
        private bool m_IsWorkSample;
        private CreateRectangleType createType;
        private ShapeType shape;
        private string id;
        protected string nameOrHoleName="";
        public string sampleName="";
        //样品孔中样品的数量
        public int sampleCount = 0;
        public string strContent;
        private Color selColor;
        private PointF m_DraggingPoint;

        private int m_sequenceNum;
     
        protected RectangleF m_RegionF;
        //绘制时与移动缩放时记录的位置与尺寸
        protected RectangleF m_OrigineRegionF;
        //private GraphicsPath g_Path=new GraphicsPath();
        private PointF startPoint;
        private PointF endPoint;
    
        //绘制颗粒图
        private Color lineColor;
        private float lineLength;
        private PointF lineStartPoint;
        private int otsX;
        private int otsY;
        //绘制样品孔BSE图像
        private Image bseImage;
        //绘制样品孔BSE图像宽度
        private float bseImageWidth;
        //绘制样品孔BSE图像高度
        private float bseImageHeight;
        //绘制样品孔BSE图像位置
        private PointF bseImageLocation;
        //绘制SEM中心位置
        private PointF semCenterPoint;
     
   
        private List<PointF> m_PolygonPoints=new List<PointF>();
        //绘制时与移动缩放时记录的位置
        private List<PointF> m_originalPolygonPoints = new List<PointF>();

        private List<CRectangleGDIObject> subItems=new List<CRectangleGDIObject>();

      
        protected float m_zoomNum=1;

        private PointF m_refPoint=new PointF(0,0);

        
    }

  
    public enum XYIndex
    {
        X = 0,
        Y = 1
    }
   
    public enum CreateRectangleType
    {
        //样品台-圆形
        SampleBackGround_Circle = -1,
        //圆形
        Circle = 0,
        //圆角矩形
        SampleBackGround_Rectangle = 1,
        //样品孔中的文字
        Text = 2,
        //矩形
        Rectangle = 3,
        //选择的样品
        SelectSample = 4,
        //测量区域
        MeasureArea = 5,
        //帧图-直线绘制方式
        SingleLine = 6,
        //表样-矩形
        SpecimenRectangle = 7,
        //表样-圆形
        SpecimenCircle = 8,
        //帧图-矩形绘制
        FieldRectangle = 9,
        //颗粒直线图
        ParticleLine = 10,
        //颗粒分布图 鼠标
        ParticleAreaRectangle = 11,
        //绘制拍摄样品孔BSE照片
        DrawFrameOfHoleBSEImage = 12,
        //绘制sem中心点+
        DrawSEMCenterPoint=13,
        //绘制BSE采集标记
        DrawBSEElementSignPoint = 14,
        //多边形
        Polygon = 15,
        //多边形完成标识
        DrawPolygonFinish = 16,
        //圆形三点法
        CircleByThreePoints=17,

        RingShape=18
    }
  

  



    public enum ColorType
    {
        FieldColor,//帧图fd8f8f
        RoundRectangleColor,//c8c8c8圆角矩形
        SampleBackGroundColor,//c0c0c0圆角矩形
        FontColor,//90ee90文字颜色
        SampleColor,//f4f4f4 样品未选择
        SampleSelColor//505050 样品选择后
    }
    
    public enum GrayLevel
    {
        Min=0,
        Max=255
    }
}