等高线自适应分割

根据已知数据，最大值最小值和计划设定的等高线条数，获取最合适的，等高线分割和等高线条数；

采用缺省的，0.1，0.2，0.25，0.5的整数倍分割

 /// <summary>
        /// 计算等高线分割
        /// </summary>
        /// <param name="cormax">数据最大值</param>
        /// <param name="cormin">数据最小值</param>
        /// <param name="cornumber">计划设定等高线条数</param>
        private void Standard(ref double cormax, ref double cormin, ref double cornumber)
        {
            double corstep, tmpstep, tmpnumber, temp, extranumber;
            if (cormax <= cormin)
                return;
            corstep = (cormax - cormin) / cornumber;
            if (Math.Pow(10, (int)(Math.Log(corstep) / Math.Log(10))) == corstep)
            {
                temp = Math.Pow(10, (int)(Math.Log(corstep) / Math.Log(10)));
            }
            else
            {
                temp = Math.Pow(10, ((int)(Math.Log(corstep) / Math.Log(10)) + 1));
            }
            tmpstep = Math.Round(corstep / temp, 6);
            //选取规范步长
            if (tmpstep >= 0 && tmpstep <= 0.1)
            {
                tmpstep = 0.1;
            }
            else if (tmpstep >= 0.100001 && tmpstep <= 0.2)
            {
                tmpstep = 0.2;
            }
            else if (tmpstep >= 0.200001 && tmpstep <= 0.25)
            {
                tmpstep = 0.25;
            }
            else if (tmpstep >= 0.250001 && tmpstep <= 0.5)
            {
                tmpstep = 0.5;
            }
            else
            {
                tmpstep = 1;
            }
            tmpstep = tmpstep * temp;
            if ((int)(cormin / tmpstep) != (cormin / tmpstep))
            {
                if (cormin < 0)
                {
                    cormin = (-1) * Math.Ceiling(Math.Abs(cormin / tmpstep)) * tmpstep;
                }
                else
                {
                    cormin = (int)(Math.Abs(cormin / tmpstep)) * tmpstep;
                }

            }
            if ((int)(cormax / tmpstep) != (cormax / tmpstep))
            {
                cormax = (int)(cormax / tmpstep + 1) * tmpstep;
            }
            tmpnumber = (cormax - cormin) / tmpstep;
            if (tmpnumber < cornumber)
            {
                extranumber = cornumber - tmpnumber;
                tmpnumber = cornumber;
                if (extranumber % 2 == 0)
                {
                    cormax = cormax + tmpstep * (int)(extranumber / 2);
                }
                else
                {
                    cormax = cormax + tmpstep * (int)(extranumber / 2 + 1);
                }
                cormin = cormin - tmpstep * (int)(extranumber / 2);
            }
            cornumber = tmpnumber;
        }

 采用数据间隔的下一位作为最小分割位，执行等高线分割操作

 /// <summary>
        /// 计算等高线分割
        /// </summary>
        /// <param name="cormax"></param>
        /// <param name="cormin"></param>
        /// <param name="cornumber"></param>
        private void Standard2(ref double cormax, ref double cormin, ref int cornumber)
        {
            decimal max = (decimal)cormax;
            if (cormax > 0)
            {
                double lmax = Math.Log10(cormax);
                int fmax = (int)Math.Floor(lmax - 1);
                double pmax = Math.Pow(10, fmax);
                max = (decimal)Math.Ceiling(cormax / pmax) * (decimal)pmax;
            }
            else if (cormax < 0)
            {
                double lmax = Math.Log10(-cormax);
                int fmax = (int)Math.Floor(lmax - 1);
                double pmax = Math.Pow(10, fmax);
                max = (decimal)Math.Floor(cormax / pmax) * (decimal)pmax;
            }
            double corstep = (cormax - cormin) / (cornumber - 1);

            double lstep = Math.Log10(corstep);
            int fstep = (int)Math.Floor(lstep - 1);
            double pstep = Math.Pow(10, fstep);
            decimal step = (decimal)Math.Ceiling(corstep / pstep) * (decimal)pstep;

            decimal min = max - (step * cornumber);
            cormax = (double)max;
            cormin = (double)min;
        }