kev/Drawer/UCDraw/SigmaDrawerElement/DrawerSurface.cs

// <copyright file="DrawerSurface.cs" company="PlaceholderCompany">
// Copyright (c) PlaceholderCompany. All rights reserved.
// </copyright>

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
#if WEB_SERVICE
#else
using System.Drawing.Design;
#endif
using System.Linq;
using System.Xml.Serialization;
using GeoSigma;
using GeoSigma.SigmaDrawerStyle;
using GeoSigma.SigmaDrawerUtil;
using GeoSigmaDrawLib;
using SigmaDrawerStyle;

namespace SigmaDrawerElement
{
    [TypeConverter(typeof(PropertySorter))]
    public class DrawerSurface : ElementBase
    {
        /// <summary>
        /// 属性类别排序
        /// </summary>
        private List<string> categorys = new List<string>() { "基础属性", "曲面", "颜色标尺", "光照", "数据", "其他", "杂项" };
        public DrawerSurface()
        {
            ElementType = DrawElementType.ELEMENT_MESH;
        }

        #region Other
        [XmlIgnore]
        [Category("数据"), DisplayName("名字"), ReadOnly(true)]
        public override string Name
        {
            get
            {
                return base.Name;
            }
            set
            {
                base.Name = value;
            }
        }

        [Category("光照"), DisplayName("启用"), PropertyOrder(0)]
        [TypeConverter(typeof(GeoSigma.SigmaDrawerStyle.Converter.YesNoConverter))]
        public bool LightEnable { get; set; } = false;

        private float lightAzimuth;

        [Category("光照"), DisplayName("水平照射角度(度)"),PropertyOrder(1)]
        public float LightAzimuth
        {
            get { return lightAzimuth; }
            set { lightAzimuth = GetValueInRange(value, 0.0f, 360.0f); }
        }

        private float lightElevation;

        [Category("光照"), DisplayName("垂直照射角度(度)"), PropertyOrder(2)]
        public float LightElevation
        {
            get { return lightElevation; }
            set { lightElevation = GetValueInRange(value, 0.0f, 90.0f); }
        }

        private float lightIntensity;

        [Category("光照"), DisplayName("环境光强度"), PropertyOrder(3)]
        public float LightIntensity
        {
            get { return lightIntensity; }
            set { lightIntensity = GetValueInRange(value, 0.0f, 1.0f); }
        }

        private float zScaleFactor;

        [Category("光照"), DisplayName("Z轴缩放因子"), PropertyOrder(4)]
        public float ZScaleFactor
        {
            get { return zScaleFactor; }
            set { zScaleFactor = value; }
        }

        [Browsable(false)]
        [XmlElement("Other")]
        // [TypeConverter(typeof(SigmaDrawerStyle.Converter.BaseExpandableConverter))]
        public SfOther Other { get; set; } = new SfOther();

        [XmlIgnore]
        [Category("曲面"), DisplayName("加密次数"), PropertyOrder(0)]
        public int OtherTimes
        {
            get => Other.Times;
            set => Other.Times = value;
        }
        /// <summary>
        /// Gets or sets 自动设置标尺.
        /// </summary>
        /// <value>
        ///   <c>true</c> if [automatic update]; otherwise, <c>false</c>.
        /// </value>
        [XmlIgnore]
        [Category("颜色标尺"), DisplayName("自动设置"), PropertyOrder(1)]
        [TypeConverter(typeof(GeoSigma.SigmaDrawerStyle.Converter.YesNoConverter))]
        public bool AutoUpdate
        {
            get
            {
                if ((Other.Style & (int)MeshAlphaType.MESH_UPDATE_RULER) > 0)
                {
                    return true;
                }
                return false;
            }
            set
            {
                if (value == true)
                {
                    Other.Style |= (int)MeshAlphaType.MESH_UPDATE_RULER;
                }
                else
                {
                    Other.Style &= ~(int)MeshAlphaType.MESH_UPDATE_RULER;
                }
            }
        }

        [XmlIgnore]
        [TypeConverter(typeof(Converter.MeshAlphaTypeConverter1)), PropertyOrder(2)]
        [Category("曲面"), DisplayName("透明处理"), ReadOnly(false)]
        public int OtherStyle1
        {
            get => Other.Style & (int)MeshAlphaType.IMAGE_TRANSPARENT_ALL;
            set
            {
                Other.Style &= ~(int)MeshAlphaType.IMAGE_TRANSPARENT_ALL;
                Other.Style |= value;
            }
        }

        [Browsable(false)]
        [XmlIgnore]
        public int OtherAlpha
        {
            get => this.Other.Alpha;
            set => Other.Alpha = value;
        }

        [XmlIgnore]
        [Category("曲面"), DisplayName("透明色"), ReadOnly(false), PropertyOrder(3)]
#if WEB_SERVICE
#else
        [Editor(typeof(PropertyEditorColor), typeof(UITypeEditor))]
#endif
        //[TypeConverter(typeof(PropertyColorIndicatorConvert))]
        public Color TransparentColor
        {
            get
            {
                return ColorTranslator.FromWin32(OtherAlpha);
            }
            set
            {
                OtherAlpha = ColorTranslator.ToWin32(value);
            }
        }

#endregion

        [XmlIgnore]
        [TypeConverter(typeof(Converter.MeshAlphaTypeConverter2))]
        [Category("曲面"), DisplayName("处理方式"), PropertyOrder(4)]
        public int OtherStyle2
        {
            get => Other.Style & (int)MeshAlphaType.MESH_DIFFERENTIAL_ALL;
            set
            {
                Other.Style &= ~(int)MeshAlphaType.MESH_DIFFERENTIAL_ALL;
                Other.Style |= value;
            }
        }

        private ValueRange _RangeZ = new ValueRange();
        [XmlIgnore]
        [Category("曲面"), DisplayName("Z值范围"), PropertyOrder(5)]
        [TypeConverter(typeof(PropertyRangeConvert))]
        public ValueRange RangeZ
        {
            get
            {
                if (_RangeZ == null)
                {
                    _RangeZ = new ValueRange(0, 100);
                }
                return _RangeZ;
            }
            set
            {
                _RangeZ = value;
                _RangeZ.Zmin = value.Zmin;
                _RangeZ.Zmax = value.Zmax;

                //当颜色标尺 自动设置为跟随才设置
                if (AutoUpdate)
                {
                    RulerRangeZ = _RangeZ;
                }
            }
        }

        private MeshStepRange _Step = new MeshStepRange();
        [XmlIgnore]
        [Category("曲面"), DisplayName("网格间隔"), ReadOnly(true), PropertyOrder(6)]
        public MeshStepRange MeshStep
        {
            get
            {
                if (_Step == null)
                {
                    _Step = new MeshStepRange(0, 100);
                }
                return _Step;
            }
            set
            {
                _Step = value;
                _Step.XStep = value.XStep;
                _Step.YStep = value.YStep;
            }
        }

        private MeshNumberRange _Num = new MeshNumberRange();
        [XmlIgnore]
        [Category("曲面"), DisplayName("网格数目"), ReadOnly(true), PropertyOrder(7)]
        public MeshNumberRange MeshNum
        {
            get
            {
                if (_Num == null)
                {
                    _Num = new MeshNumberRange(0, 100);
                }
                return _Num;
            }
            set
            {
                _Num = value;
                _Num.XNum = value.XNum;
                _Num.YNum = value.YNum;
            }
        }

        #region ColorRuler
        [DisplayName("颜色标尺")]
        public class SfColorRuler
        {
            #region Coordinate
            public class SfCoordinate
            {
                //public class SfPoint
                //{
                //    public double X { get; set; }

                //    public double Y { get; set; }

                //    public override string ToString()
                //    {
                //        return $"{X},{Y}";
                //    }
                //}

                //public class SfSize
                //{
                //    [DisplayName("\t\t\t宽度")]
                //    public double Width { get; set; }

                //    [DisplayName("\t\t高度")]
                //    public double Height { get; set; }

                //    public override string ToString()
                //    {
                //        return $"{Width},{Height}";
                //    }
                //}

                [XmlText]
                public string Text
                {
                    get
                    {
                        return $"{Point.X},{Point.Y} {Point.X + RulerSize.Width},{Point.Y + RulerSize.Height}";
                    }
                    set
                    {
                        var arr = value.Split(new string[] { ",", " ", "\t" }, StringSplitOptions.RemoveEmptyEntries);

                        if (arr.Length == 4)
                        {
                            Point.X = Convert.ToDouble(arr[0]);
                            Point.Y = Convert.ToDouble(arr[1]);

                            var xMax = Convert.ToDouble(arr[2]);
                            var yMax = Convert.ToDouble(arr[3]);

                            this.RulerSize = new SizeF((float)(xMax - Point.X), (float)(yMax - Point.Y));
                        }
                    }
                }

                [XmlIgnore]
                public PropertyPoint Point { get; set; } = new PropertyPoint();

                [XmlIgnore]
                public SizeF RulerSize { get; set; } = default(SizeF);
            }

            //[Browsable(false)]
            [XmlElement("Coordinate")]
            [TypeConverter(typeof(GeoSigma.SigmaDrawerStyle.Converter.BaseExpandableConverter)), ReadOnly(true)]
            public SfCoordinate Coordinate { get; set; } = new SfCoordinate();
            #endregion

            [XmlElement("RangeZ")]

            public SfcrRangeZ RangeZ { get; set; } = new SfcrRangeZ();

            [XmlElement("Other")]
            public SfcrOther Other { get; set; } = new SfcrOther();

            /// <summary>
            /// 直接在 ColorRuler 节点下定义 Item 集合
            /// </summary>
            [XmlElement("Item")]
            public List<SfRulerCustomItem> CustomItems { get; set; } = new List<SfRulerCustomItem>();

            [TypeConverter(typeof(GeoSigma.SigmaDrawerStyle.Converter.BaseExpandableConverter))]
            public class SfcrRangeZ
            {
                [DisplayName("\t\t最小")]
                [XmlAttribute]
                public double Zmin { get; set; }

                [DisplayName("\t\t\t最大")]
                [XmlAttribute]
                public double Zmax { get; set; }

                [DisplayName("\t步长")]
                [XmlAttribute]
                public double Delt { get; set; }

                public override string ToString()
                {
                    return $"{Zmin}, {Zmax}";
                }
            }

            [TypeConverter(typeof(GeoSigma.SigmaDrawerStyle.Converter.BaseExpandableConverter))]
            public class SfcrOther
            {
                [XmlAttribute]
                public double TextHeight { get; set; }

                [XmlAttribute]
                public int Style { get; set; }

                [XmlAttribute]
                public int Number { get; set; }

                [XmlAttribute]
                public int DF { get; set; }

                // 新增一个独立的属性，XmlAttribute 确保它会被序列化保存
                // int 默认值为 0，对应枚举的 "平均标注"，正好满足默认值需求
                [XmlAttribute]
                public int RulerLabelVal { get; set; } = 0;
            }
        }

        [XmlElement("ColorRuler")]
        [Browsable(false)]
        [TypeConverter(typeof(GeoSigma.SigmaDrawerStyle.Converter.BaseExpandableConverter))]
        public SfColorRuler ColorRuler { get; set; } = new SfColorRuler();

        [XmlIgnore]
        [Category("颜色标尺"), DisplayName("显示标尺"), PropertyOrder(0)]
        [TypeConverter(typeof(GeoSigma.SigmaDrawerStyle.Converter.YesNoConverter))]
        public bool RulerShow
        {
            get => (Other.Style & (int)MeshAlphaType.MESH_DRAW_RULER) == (int)MeshAlphaType.MESH_DRAW_RULER;
            set
            {
                if (value)
                {
                    Other.Style |= (int)MeshAlphaType.MESH_DRAW_RULER;
                }
                else
                {
                    Other.Style &= ~(int)MeshAlphaType.MESH_DRAW_RULER;
                }
            }
        }

        [XmlIgnore]
        [Category("颜色标尺"), DisplayName("反转显示"), PropertyOrder(2)]
        [TypeConverter(typeof(GeoSigma.SigmaDrawerStyle.Converter.YesNoConverter)), ReadOnly(false)]
        public bool RulerStyleReverse
        {
            get => (ColorRuler.Other.Style & (int)MeshRulerIdea.COLOR_RULER_REVERSAL) == (int)MeshRulerIdea.COLOR_RULER_REVERSAL;
            set
            {
                if (value)
                {
                    ColorRuler.Other.Style |= (int)MeshRulerIdea.COLOR_RULER_REVERSAL;
                }
                else
                {
                    ColorRuler.Other.Style &= ~(int)MeshRulerIdea.COLOR_RULER_REVERSAL;
                }
            }
        }
        [XmlIgnore]
        [Browsable(false)]
        [Category("颜色标尺"), DisplayName("显示方式"), PropertyOrder(3)]
        [TypeConverter(typeof(Converter.MeshRulerIdeaConverter))]
        public int RulerStyle
        {
            get => ColorRuler.Other.Style & (int)MeshRulerIdea.COLOR_RULER_HV_ALL;
            set
            {
                ColorRuler.Other.Style &= ~(int)MeshRulerIdea.COLOR_RULER_HV_ALL;
                ColorRuler.Other.Style |= value;
            }
        }
        [XmlIgnore]
        [Category("颜色标尺"), DisplayName("坐标"), ReadOnly(false), PropertyOrder(4)]
        [TypeConverter(typeof(PropertyPointConvert))]
        public PropertyPoint Point
        {
            get => ColorRuler.Coordinate.Point;
            set => ColorRuler.Coordinate.Point = value;
        }

        [XmlIgnore]
        [Category("颜色标尺"), DisplayName("尺寸"), ReadOnly(false), PropertyOrder(5)]
        [TypeConverter(typeof(PropertySizeConvert))]
        public SizeF RulerSize
        {
            get => ColorRuler.Coordinate.RulerSize;
            set => ColorRuler.Coordinate.RulerSize = value;
        }
        [XmlIgnore]
        [Category("颜色标尺"), DisplayName("文字高度"), ReadOnly(false), PropertyOrder(6)]
        public double RulerTextHeight
        {
            get => ColorRuler.Other.TextHeight;
            set => ColorRuler.Other.TextHeight = value;
        }

        [XmlIgnore]
        [TypeConverter(typeof(Converter.RulerLabelTypeConverter)), PropertyOrder(7)]
        [Category("颜色标尺"), DisplayName("标注样式"), ReadOnly(false)]
        [RefreshProperties(RefreshProperties.All)] // 必须添加，否则 UI 不会实时重绘只读状态
        public int RulerDataStyle
        {
            get => ColorRuler.Other.RulerLabelVal;
            set
            {
                int oldVal = ColorRuler.Other.RulerLabelVal;
                // 如果新值和旧值一样，不要重复触发
                if (oldVal == value) return;
                ColorRuler.Other.RulerLabelVal = value;

                if (value == 2)
                {
                    // 获取原生的 Mesh 颜色，用于固定左侧色带
                    List<ColorScaleEntry> meshEntries = MeshColor.Items.Select(item => new ColorScaleEntry
                    {
                        z = item.Z,
                        r = item.R,
                        g = item.G,
                        b = item.B,
                        a = item.T,
                        isContinue = item.C
                    }).ToList();

                    // 获取滑块的初始数据
                    List<ColorScaleEntry> markEntries = new List<ColorScaleEntry>();
                    if (ColorRuler.CustomItems != null && ColorRuler.CustomItems.Count > 0)
                    {
                        // 如果之前保存过自定义节点，加载它们
                        markEntries = ColorRuler.CustomItems.Select(item => new ColorScaleEntry
                        {
                            z = item.Z,
                            r = item.R,
                            g = item.G,
                            b = item.B,
                            a = item.T,
                            isContinue = item.C
                        }).ToList();
                    }
                    else
                    {
                        // 第一次打开，滑块默认使用 Mesh 颜色节点（深拷贝以防联动污染）
                        markEntries = meshEntries.Select(e => new ColorScaleEntry
                        {
                            z = e.z,
                            r = e.r,
                            g = e.g,
                            b = e.b,
                            a = e.a,
                            isContinue = e.isContinue
                        }).ToList();
                    }

                    var result = FrmGradientRulerEditor.ShowEditor(null, meshEntries, markEntries, RangeZ.Zmin, RangeZ.Zmax, RulerStyleReverse);
                    if (result != null)
                    {
                        ColorRuler.CustomItems.Clear();
                        foreach (var res in result)
                        {
                            ColorRuler.CustomItems.Add(new SfRulerCustomItem
                            {
                                Z = res.z,
                                R = res.r,
                                G = res.g,
                                B = res.b,
                                T = res.a,
                                C = res.isContinue
                            });
                        }
                    }
                    else
                    {
                        ColorRuler.Other.RulerLabelVal = oldVal;
                    }
                }
            }
        }

        private ValueRange _RulerRangeZ;
        [XmlIgnore]
        [Category("颜色标尺"), DisplayName("标注范围"), ReadOnly(false), PropertyOrder(8)]
        [TypeConverter(typeof(PropertyRangeConvert))]
        public ValueRange RulerRangeZ
        {
            get
            {
                if (_RulerRangeZ == null)
                {
                    _RulerRangeZ = new ValueRange();
                }
                if (ColorRuler.RangeZ != null)
                {
                    _RulerRangeZ.Zmin = ColorRuler.RangeZ.Zmin;
                    _RulerRangeZ.Zmax = ColorRuler.RangeZ.Zmax;
                }
                return _RulerRangeZ;
            }
            set
            {
                _RulerRangeZ = value;
                ColorRuler.RangeZ.Zmin = _RulerRangeZ.Zmin;
                ColorRuler.RangeZ.Zmax = _RulerRangeZ.Zmax;
            }
        }
        // TODO:步长
        [XmlIgnore]
        [Category("颜色标尺"), DisplayName("个数"), ReadOnly(false), PropertyOrder(9)]
        public int RulerNumber
        {
            get => ColorRuler.Other.Number;
            set => ColorRuler.Other.Number = value;
        }

        [XmlIgnore]
        [Category("颜色标尺"), DisplayName("保留小数位数"), ReadOnly(false), PropertyOrder(10)]
        public int RulerDF
        {
            get => ColorRuler.Other.DF;
            set => ColorRuler.Other.DF = value;
        }

        #endregion

        #region MeshColor

        [Browsable(false)]
        [XmlElement("MeshColor")]
        [TypeConverter(typeof(GeoSigma.SigmaDrawerStyle.Converter.BaseExpandableConverter))]
        public SfMeshColor MeshColor { get; set; } = new SfMeshColor();

        private GradientColors colorItems = new GradientColors();
        //[RefreshProperties(RefreshProperties.All)]
        //[NotifyParentProperty(true)]
        [Category("曲面"), DisplayName("颜色"), PropertyOrder(1)]
        [TypeConverter(typeof(GeoSigma.SigmaDrawerStyle.Converter.BaseCollectionConverter))]
        //[TypeConverter(typeof(ExpandableObjectConverter))]
#if WEB_SERVICE
#else
        [Editor("GeoSigma.SigmaDrawerStyle.PropertyEditorGradientColor, SigmaDrawerStyle", typeof(System.Drawing.Design.UITypeEditor))]
#endif
        [XmlIgnore]
        public GradientColors Items
        {
            get
            {
                if (colorItems == null)
                {
                    colorItems = new GradientColors();
                }
                else
                {
                    colorItems.Clear();
                }
                colorItems.AddRange(MeshColor.Items);
                double dZMin = RangeZ.Zmin;
                double dZMax = RangeZ.Zmax;
                if (dZMin == dZMax)
                {
                    CalculateRange(ref dZMin, ref dZMax);
                }
                colorItems.ZMin = RulerRangeZ.Zmin = dZMin;
                colorItems.ZMax = RulerRangeZ.Zmax = dZMax;
                return colorItems;
            }
            set
            {
                colorItems = value;
                MeshColor.Items.CloneFrom(colorItems);

                RulerRangeZ.Zmin = colorItems.ZMin;
                RulerRangeZ.Zmax = colorItems.ZMax;
            }
        }
        public void SetColors(GradientColors colors)
        {
            colorItems.CloneFrom(colors);
            MeshColor.Items = colorItems;

            RulerRangeZ.Zmin = colorItems.ZMin;
            RulerRangeZ.Zmax = colorItems.ZMax;
        }
        private void CalculateRange(ref double min, ref double max)
        {
            min = MeshColor.Items.Min(r => r.Z);
            max = MeshColor.Items.Max(r => r.Z);
        }
        //[Browsable(false)]
        //[XmlIgnore]
        //public List<SfMeshColor.SfmcAlphaItem> AlphItems
        //{
        //    get => MeshColor.AlphaItems;
        //    set
        //    {
        //        MeshColor.AlphaItems = value;
        //    }
        //}

#endregion

        private void GenerateMesh()
        {
            double ZMin = _RulerRangeZ.Zmin;
            double ZMax = _RulerRangeZ.Zmax;

            var origin = Items;
            var list = new GradientColors();

            var originZMin = origin.Min(r => r.Z);
            var originZMax = origin.Max(r => r.Z);

            var range = ZMax - ZMin;

            foreach (var c in origin)
            {
                var z0 = (c.Z - originZMin) / (originZMax - originZMin);

                c.Z = z0 * range + ZMin;

                list.Add(c);
            }
            Items.Clear();
            Items.AddRange(list);
        }

        private float GetValueInRange(float value, float min, float max)
        {
            if (value < min)
            {
                return min;
            }
            else if (value > max)
            {
                return max;
            }
            else
            {
                return value;
            }
        }
    }

    public class SfOther
    {
        [XmlAttribute]
        public int Style { get; set; } =
            (int)(MeshAlphaType.MESH_DRAW_RULER
            | MeshAlphaType.MESH_UPDATE_RULER
            | MeshAlphaType.MESH_TEXT
            | MeshAlphaType.MESH_SERIALIZE_RULER)
            & (~(int)MeshAlphaType.MESH_UPDATE_RULER);

        [XmlAttribute]
        public int Times { get; set; }

        [XmlAttribute]
        public int Alpha { get; set; }
    }

    /// <summary>
    /// 专门用于序列化的自定义标尺点结构
    /// </summary>
    public class SfRulerCustomItem
    {
        [XmlAttribute] public double Z { get; set; }
        [XmlAttribute] public int R { get; set; }
        [XmlAttribute] public int G { get; set; }
        [XmlAttribute] public int B { get; set; }
        [XmlAttribute] public int T { get; set; } // 对应 Alpha
        [XmlAttribute] public int C { get; set; } // 对应 isContinue
    }
}