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

namespace TProduct.PumpGraph.Picture
{
    public partial class LxpFeatChart : FeatChart
    {
        #region 曲线宽度和颜色



        protected float _curvePointSize = 8f;
        public float CurvePointSize
        {
            get { return _curvePointSize; }
            set { _curvePointSize = value; }
        }

        protected float _curvePointWidth = 2f;
        public float PointPointWidth
        {
            get { return _curvePointWidth; }
            set { _curvePointWidth = value; }
        }








        protected Color _coefficientLineColor = Color.Black;
        public Color CoefficientLineColor
        {
            get { return _coefficientLineColor; }
            set { _coefficientLineColor = value; }
        }
        protected float _coefficientLineWidth = 3f;
        public float CoefficientLineWidth
        {
            get { return _coefficientLineWidth; }
            set { _coefficientLineWidth = value; }
        }



        protected float _pointCrossLineWidth = 1f;//交叉线
        public float PointCrossLineWidth
        {
            get { return _pointCrossLineWidth; }
            set { _pointCrossLineWidth = value; }
        }

        protected float _curveNameSize = 10f;
        public float CurveNameSize
        {
            get { return _curveNameSize; }
            set { _curveNameSize = value; }
        }
        protected string _curveNameFontName = "Arial";


        protected bool _isDispCurveName = false;
        public bool IsDispCurveName
        {
            get { return _isDispCurveName; }
            set { _isDispCurveName = value; }
        }

        protected bool _isDispQNPSH = true;//是否显示汽蚀曲线
        public bool IsDispQNPSH
        {
            get { return _isDispQNPSH; }
            set { _isDispQNPSH = value; }
        }

        bool _isDispQP = true;//是否显示功率曲线
        public bool IsDispQP
        {
            get { return _isDispQP; }
            set { _isDispQP = value; }
        }
        /// <summary>
        /// 
        /// </summary>
        public bool IsAccordQE
        {
            get { return _isAccordQE; }
            set { _isAccordQE = value; }
        }
        bool _isAccordQE = true;

        bool _isAccordQH = true;
        public bool IsAccordQH
        {
            get { return _isAccordQH; }
            set { _isAccordQH = value; }
        }



        private int _curveParaTextPosi = 1;//1开始位置, 2 表示结束位置
        protected int CurveParaTextPosi
        {
            get { return _curveParaTextPosi; }
            set { _curveParaTextPosi = value; }
        }
        #endregion


        #region  绘制曲线
        protected void DrawAllCurves()
        {
            DrawCurveQH();
            DrawCurveQE();
            DrawCurveQP();
            DrawCurveQNPSH();
        }

        //绘制汽蚀曲线
        protected void DrawCurveQNPSH()
        {
            if (_points_CurveNPSH == null || _points_CurveNPSH.Count < 3)
                return;

            List<PointF> QNPSHPts = new List<PointF>();
            for (int i = 0; i < _points_CurveNPSH.Count; i++)
            {
                PointF QNPSHPt = new PointF();
                QNPSHPt.X = MapRealToPictQ(_points_CurveNPSH[i].X);
                QNPSHPt.Y = MapRealToPictNPSH(_points_CurveNPSH[i].Y);
                QNPSHPts.Add(QNPSHPt);
            }
            if (QNPSHPts.Count < 3)
                return;

            using (Pen pen = new Pen(_curveColorNPSH, base._curveWidth))
            {
                _graphics.DrawCurve(pen, QNPSHPts.ToArray());
            }

            if (_isDispCurveName)
            {
                //画曲线标签
                PointF pt1 = new PointF();
                pt1 = QNPSHPts[QNPSHPts.Count - 1];

                PointF pt2 = new PointF();
                pt2.X = pt1.X + 10;
                pt2.Y = pt1.Y - 10;
                string title = "Q-NPSH";

                using (var font = new Font(_curveNameFontName, _curveNameSize,
                System.Drawing.FontStyle.Regular |
                System.Drawing.FontStyle.Bold))
                {
                    _graphics.DrawString(title, font, new SolidBrush(Color.Black), pt2);
                }
            }
        }

        //绘制扬程曲线
        protected void DrawCurveQH()
        {
            if (_curveInfoQH == null)
                return;
            //画曲线 
            DrawSingleCurveQH(this._curveInfoQH, this._curveColorQH, this._curveWidth);

            DrawCurveLabelQH();
        }

        protected virtual void DrawCurveLabelQH()
        {
            //画曲线标签
            if (_isDispCurveName)
            {
                PointF pt1 = new PointF();
                pt1.X = MapRealToPictQ(_curveInfoQH[_curveInfoQH.Count - 2].X);
                pt1.Y = MapRealToPictH(_curveInfoQH[_curveInfoQH.Count - 2].Y);

                PointF pt2 = new PointF();
                pt2.X = pt1.X + 10;
                pt2.Y = pt1.Y - 10;
                string title = "Q-H";

                using (var font = new Font(_curveNameFontName, _curveNameSize,
         System.Drawing.FontStyle.Regular |
         System.Drawing.FontStyle.Bold))
                {
                    _graphics.DrawString(title, font, new SolidBrush(_curveColorQH), pt2);
                }
            }
        }

        //绘制效率曲线
        protected void DrawCurveQE()
        {
            if (_curveInfoQE == null)
                return;

            //画曲线 
            DrawSingleCurveQE(_curveInfoQE, this._curveColorQE, this._curveWidth);
            DrawCurveLabelQE();
        }

        protected virtual void DrawCurveLabelQE()
        {
            //画曲线标签
            if (_isDispCurveName)
            {
                PointF pt1 = new PointF();
                pt1.X = MapRealToPictQ(_curveInfoQE[_curveInfoQE.Count - 2].X);
                pt1.Y = MapRealToPictE(_curveInfoQE[_curveInfoQE.Count - 2].Y);

                PointF pt2 = new PointF();
                pt2.X = pt1.X + 10;
                pt2.Y = pt1.Y - 10;
                string title = "Q-η";
                using (var font = new Font(_curveNameFontName, _curveNameSize,
        System.Drawing.FontStyle.Regular |
        System.Drawing.FontStyle.Bold))
                {
                    _graphics.DrawString(title, font, new SolidBrush(_curveColorQE), pt2);
                }
            }

        }

        //绘制功率曲线
        protected void DrawCurveQP()
        {
            if (_curveInfoQP == null)
                return;
            DrawSingleCurveQP(_curveInfoQP, this._curveColorQP, this._curveWidth);

            DrawCurveLabelQP();
        }

        protected virtual void DrawCurveLabelQP()
        {
            //画曲线标签
            if (_isDispCurveName)
            {
                PointF pt1 = new PointF();
                pt1.X = MapRealToPictQ(_curveInfoQP[_curveInfoQP.Count - 2].X);
                pt1.Y = MapRealToPictP(_curveInfoQP[_curveInfoQP.Count - 2].Y);

                PointF pt2 = new PointF();
                pt2.X = pt1.X + 10;
                pt2.Y = pt1.Y - 10;
                string title = "Q-P";

                using (var font = new Font(_curveNameFontName, _curveNameSize,
        System.Drawing.FontStyle.Regular |
        System.Drawing.FontStyle.Bold))
                {
                    _graphics.DrawString(title, font, new SolidBrush(_curveColorQP), pt2);
                }
            }
        }







        //
        protected void DrawSingleCurveQH(
            List<Eventech.Model.FeatPoint> curvePoints,
            System.Drawing.Color curveColor,
            float curveWidth,
            DashStyle DashStyle = DashStyle.Solid)
        {
            if (curvePoints == null || curvePoints.Count < 3)
                return;
            if (this._isMonoColor)
                curveColor = Color.Black;
            List<PointF> picture_points = new List<PointF>();
            for (int i = 0; i < curvePoints.Count; i++)
            {
                PointF image_pt = new PointF();
                image_pt.X = MapRealToPictQ(curvePoints[i].X);
                image_pt.Y = MapRealToPictH(curvePoints[i].Y);
                picture_points.Add(image_pt);
            }
            //去掉重曲线复点
            //Point[] pointArray = screenPoints.Distinct().ToArray();
            using (Pen pen = new Pen(curveColor, curveWidth))
            {
                pen.DashStyle = DashStyle;
                //penMajorTick.DashPattern = new float[] { 3f, 3f };

                _graphics.DrawCurve(pen, picture_points.ToArray());
            }
        }
        //
        protected void DrawSingleCurveQE(List<Eventech.Model.FeatPoint> curvePoints, System.Drawing.Color curveColor, float curveWidth, DashStyle DashStyle = DashStyle.Solid)
        {
            if (curvePoints == null || curvePoints.Count < 3)
                return;
            if (this._isMonoColor)
                curveColor = Color.Black;
            List<PointF> picture_points = new List<PointF>();
            for (int i = 0; i < curvePoints.Count; i++)
            {
                PointF image_pt = new PointF();
                image_pt.X = MapRealToPictQ(curvePoints[i].X);
                image_pt.Y = MapRealToPictE(curvePoints[i].Y);
                picture_points.Add(image_pt);
            }
            //去掉重曲线复点
            //Point[] pointArray = screenPoints.Distinct().ToArray();
            using (Pen pen = new Pen(curveColor, curveWidth))
            {
                pen.DashStyle = DashStyle;
                _graphics.DrawCurve(pen, picture_points.ToArray());
            }
        }
        //
        protected void DrawSingleCurveQP(List<Eventech.Model.FeatPoint> curvePoints, System.Drawing.Color curveColor, float curveWidth, DashStyle DashStyle = DashStyle.Solid)
        {
            if (curvePoints == null || curvePoints.Count < 3)
                return;
            List<PointF> picture_points = new List<PointF>();
            for (int i = 0; i < curvePoints.Count; i++)
            {
                PointF image_pt = new PointF();
                image_pt.X = MapRealToPictQ(curvePoints[i].X);
                image_pt.Y = MapRealToPictP(curvePoints[i].Y);
                picture_points.Add(image_pt);
            }
            //去掉重曲线复点
            //Point[] pointArray = screenPoints.Distinct().ToArray();
            if (this._isMonoColor)
                curveColor = Color.Black;
            using (Pen pen = new Pen(curveColor, curveWidth))
            {
                pen.DashStyle = DashStyle;
                _graphics.DrawCurve(pen, picture_points.ToArray());
            }
        }
        //
        protected void DrawSingleCurveQNPSH(List<Eventech.Model.FeatPoint> curvePoints, System.Drawing.Color curveColor, float curveWidth, DashStyle DashStyle = DashStyle.Solid)
        {
            if (curvePoints == null || curvePoints.Count < 3)
                return;
            if (this._isMonoColor)
                curveColor = Color.Black;

            List<PointF> picture_points = new List<PointF>();
            for (int i = 0; i < curvePoints.Count; i++)
            {
                PointF image_pt = new PointF();
                image_pt.X = MapRealToPictQ(curvePoints[i].X);
                image_pt.Y = MapRealToPictNPSH(curvePoints[i].Y);
                picture_points.Add(image_pt);
            }
            //去掉重曲线复点
            //Point[] pointArray = screenPoints.Distinct().ToArray();
            using (Pen pen = new Pen(curveColor, curveWidth))
            {
                pen.DashStyle = DashStyle;
                _graphics.DrawCurve(pen, picture_points.ToArray());
            }

        }

        #endregion



        #region 测试点
        protected void DrawAllPoint()
        {
            DrawPointQH();
            DrawPointQE();
            DrawPointQP();
            DrawPointQNPSH();
        }

        protected void DrawPointQH()
        {
            if (_pointInfoQH == null || _pointInfoQH.Count < 1)
                return;

            for (int i = 0; i < _pointInfoQH.Count; i++)
            {
                PointF pt = new PointF();
                pt.X = MapRealToPictQ(_pointInfoQH[i].X);
                pt.Y = MapRealToPictH(_pointInfoQH[i].Y);

                DrawPoint_CircleStyle(pt, true, this._curveColorQH, this._curvePointSize, this._curvePointWidth);
            }
        }

        protected void DrawPointQE()
        {
            if (_pointInfoQE == null || _pointInfoQE.Count < 1)
                return;

            for (int i = 0; i < _pointInfoQE.Count; i++)
            {
                PointF pt = new PointF();
                pt.X = MapRealToPictQ(_pointInfoQE[i].X);
                pt.Y = MapRealToPictE(_pointInfoQE[i].Y);

                DrawPoint_RectStyle(pt, true, _curveColorQE, this._curvePointSize, this._curvePointWidth);

            }
        }

        protected void DrawPointQP()
        {
            if (_pointInfoQP == null || _pointInfoQP.Count < 1)
                return;

            for (int i = 0; i < _pointInfoQP.Count; i++)
            {
                PointF pt = new PointF();
                pt.X = MapRealToPictQ(_pointInfoQP[i].X);
                pt.Y = MapRealToPictP(_pointInfoQP[i].Y);

                DrawPoint_CrossStyle(pt, _curveColorQP, this._curvePointSize, this._curvePointWidth);
            }
        }

        protected void DrawPointQNPSH()
        {
            if (_points_TestNPSH == null || _points_TestNPSH.Count < 1)
                return;

            for (int i = 0; i < _points_TestNPSH.Count; i++)
            {
                PointF pt = new PointF();
                pt.X = MapRealToPictQ(_points_TestNPSH[i].X);
                pt.Y = MapRealToPictNPSH(_points_TestNPSH[i].Y);

                DrawPoint_RectStyle(pt, true, _curveColorNPSH, this._curvePointSize, this._curvePointWidth);
            }
        }
        #endregion


        #region 最小流量线

        Eventech.Model.FeatPointList _minFlowCurve;
        public Eventech.Model.FeatPointList MinFlowCurve
        {
            get { return _minFlowCurve; }
            set { _minFlowCurve = value; }
        }
        #endregion



        #region 型谱
        //型谱颜色
        protected Color _spectrumBackColor = Color.FromArgb(60, Color.Gray);

        //型谱形状
        protected Eventech.Model.LxpSpectrumShape _spectrumShape = null;
        public Eventech.Model.LxpSpectrumShape SpectrumShape
        {
            get { return _spectrumShape; }
            set { _spectrumShape = value; }
        }

        //是否显示型谱
        protected bool _isDispSpectrum = true;
        public bool IsDispSpectrum { get { return _isDispSpectrum; } set { _isDispSpectrum = value; } }
        #endregion


        #region 区域
        protected Eventech.Model.LxpRegionPointParas _regionPointParas = null;

        public bool SetRegionParas(Eventech.Model.LxpPerformParas lxpPerformParas, Eventech.Model.LxpCurveGroupExpress wrkCurve)
        {
            if (lxpPerformParas == null || wrkCurve == null)
                return false;
            if (wrkCurve == null)
                return false;

            this._regionPointParas = new Eventech.Model.LxpRegionPointParas();

            if (lxpPerformParas.PreferredRegionMin > 0.1)
            {
                this._regionPointParas.PerferRegionMin = new Eventech.Model.GroupPoint();
                _regionPointParas.PerferRegionMin.Q = lxpPerformParas.PreferredRegionMin;
                _regionPointParas.PerferRegionMin.H = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQH, lxpPerformParas.PreferredRegionMin), 1);
                _regionPointParas.PerferRegionMin.E = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQE, lxpPerformParas.PreferredRegionMin), 1);
                _regionPointParas.PerferRegionMin.P = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQP, lxpPerformParas.PreferredRegionMin), 2);
                if (wrkCurve.CurveExpressNPSH != null)
                {
                    this._regionPointParas.PerferRegionMin.NPSH = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressNPSH, this._regionPointParas.PerferRegionMin.Q), 1);
                }
            }


            if (lxpPerformParas.PreferredRegionMax > 0.1)
            {
                this._regionPointParas.PerferRegionMax = new Eventech.Model.GroupPoint();
                _regionPointParas.PerferRegionMax.Q = lxpPerformParas.PreferredRegionMax;
                _regionPointParas.PerferRegionMax.H = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQH, lxpPerformParas.PreferredRegionMax), 1);
                _regionPointParas.PerferRegionMax.E = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQE, lxpPerformParas.PreferredRegionMax), 1);
                _regionPointParas.PerferRegionMax.P = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQP, lxpPerformParas.PreferredRegionMax), 2);
                if (wrkCurve.CurveExpressNPSH != null)
                {
                    this._regionPointParas.PerferRegionMax.NPSH = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressNPSH, this._regionPointParas.PerferRegionMax.Q), 1);
                }
            }



            if (lxpPerformParas.AllowableRegionMin > 0.1)
            {
                this._regionPointParas.AllowRegionMin = new Eventech.Model.GroupPoint();
                this._regionPointParas.AllowRegionMin.Q = lxpPerformParas.AllowableRegionMin;
                this._regionPointParas.AllowRegionMin.H = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQH, lxpPerformParas.AllowableRegionMin), 1);
                this._regionPointParas.AllowRegionMin.E = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQE, lxpPerformParas.AllowableRegionMin), 1);
                this._regionPointParas.AllowRegionMin.P = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQP, lxpPerformParas.AllowableRegionMin), 2);

                if (wrkCurve.CurveExpressNPSH != null)
                {
                    this._regionPointParas.AllowRegionMin.NPSH = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressNPSH, this._regionPointParas.AllowRegionMin.Q), 1);
                }
            }


            if (lxpPerformParas.AllowableRegionMax > 0.1)
            {
                this._regionPointParas.AllowRegionMax = new Eventech.Model.GroupPoint();
                this._regionPointParas.AllowRegionMax.Q = lxpPerformParas.AllowableRegionMax;
                this._regionPointParas.AllowRegionMax.H = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQH, lxpPerformParas.AllowableRegionMax), 1);
                this._regionPointParas.AllowRegionMax.E = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQE, lxpPerformParas.AllowableRegionMax), 1);
                this._regionPointParas.AllowRegionMax.P = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressQP, lxpPerformParas.AllowableRegionMax), 2);

                if (wrkCurve.CurveExpressNPSH != null)
                {
                    this._regionPointParas.AllowRegionMax.NPSH = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.CurveExpressNPSH, this._regionPointParas.AllowRegionMax.Q), 1);
                }
            }







            return true;
        }

        public bool SetRegionParas(Eventech.Model.LxpPerformParas lxpPerformParas, Eventech.Model.LxpFeatChartCurveGroup wrkCurve)
        {
            if (lxpPerformParas == null || wrkCurve == null)
                return false;

            this._regionPointParas = new Eventech.Model.LxpRegionPointParas();

            this._regionPointParas.PerferRegionMax = new Eventech.Model.GroupPoint();
            this._regionPointParas.PerferRegionMax.Q = lxpPerformParas.PreferredRegionMax;
            this._regionPointParas.PerferRegionMax.H = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQH.CurveExpress, lxpPerformParas.PreferredRegionMax), 1);
            this._regionPointParas.PerferRegionMax.E = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQE.CurveExpress, lxpPerformParas.PreferredRegionMax), 1);
            this._regionPointParas.PerferRegionMax.P = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQP.CurveExpress, lxpPerformParas.PreferredRegionMax), 2);


            this._regionPointParas.PerferRegionMin = new Eventech.Model.GroupPoint();
            this._regionPointParas.PerferRegionMin.Q = lxpPerformParas.PreferredRegionMin;
            this._regionPointParas.PerferRegionMin.H = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQH.CurveExpress, lxpPerformParas.PreferredRegionMin), 1);
            this._regionPointParas.PerferRegionMin.E = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQE.CurveExpress, lxpPerformParas.PreferredRegionMin), 1);
            this._regionPointParas.PerferRegionMin.P = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQP.CurveExpress, lxpPerformParas.PreferredRegionMin), 2);


            this._regionPointParas.AllowRegionMax = new Eventech.Model.GroupPoint();
            this._regionPointParas.AllowRegionMax.Q = lxpPerformParas.AllowableRegionMax;
            this._regionPointParas.AllowRegionMax.H = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQH.CurveExpress, lxpPerformParas.AllowableRegionMax), 1);
            this._regionPointParas.AllowRegionMax.E = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQE.CurveExpress, lxpPerformParas.AllowableRegionMax), 1);
            this._regionPointParas.AllowRegionMax.P = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQP.CurveExpress, lxpPerformParas.AllowableRegionMax), 2);


            this._regionPointParas.AllowRegionMin = new Eventech.Model.GroupPoint();
            this._regionPointParas.AllowRegionMin.Q = lxpPerformParas.AllowableRegionMin;
            this._regionPointParas.AllowRegionMin.H = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQH.CurveExpress, lxpPerformParas.AllowableRegionMin), 1);
            this._regionPointParas.AllowRegionMin.E = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQE.CurveExpress, lxpPerformParas.AllowableRegionMin), 1);
            this._regionPointParas.AllowRegionMin.P = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveQP.CurveExpress, lxpPerformParas.AllowableRegionMin), 2);


            if (wrkCurve.FeatCurveNPSH != null && wrkCurve.FeatCurveNPSH.CurveExpress != null)
            {
                this._regionPointParas.AllowRegionMin.NPSH = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveNPSH.CurveExpress, this._regionPointParas.AllowRegionMin.Q), 1);
                this._regionPointParas.AllowRegionMax.NPSH = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveNPSH.CurveExpress, this._regionPointParas.AllowRegionMax.Q), 1);

                this._regionPointParas.PerferRegionMin.NPSH = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveNPSH.CurveExpress, this._regionPointParas.PerferRegionMin.Q), 1);
                this._regionPointParas.PerferRegionMax.NPSH = Math.Round(Eventech.Common.FitCurveHelper.GetFitPointY(wrkCurve.FeatCurveNPSH.CurveExpress, this._regionPointParas.PerferRegionMax.Q), 1);
            }


            return true;
        }

        public bool SetRegionParas(Eventech.Model.LxpRegionPointParas regionPointParas)
        {
            _regionPointParas = regionPointParas;
            return true;
        }
        //最优区域(是否显示)
        protected bool _isDispRegionPrefer = false;
        public bool IsDispRegionPrefer
        {
            get { return _isDispRegionPrefer; }
            set { _isDispRegionPrefer = value; }
        }


        //允许区域(是否显示)
        protected bool _isDispRegionAllow = false;
        public bool IsDispRegionAllow
        {
            get { return _isDispRegionAllow; }
            set { _isDispRegionAllow = value; }
        }
        #endregion

    }
}