Metis_xctg/AutoAnalysis/RulerPainter.cs

using PaintDotNet;
using PaintDotNet.Base.CommTool;
using PaintDotNet.Base.SettingModel;
using PaintDotNet.DbOpreate.DbModel;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Metis.AutoAnalysis
{
    class RulerPainter
    {
        public RulerModel rulerModel;//标尺样式信息

        public int lineLength = 1;//标尺长度
        public bool getLengthFromConfig = true;//是否从配置文件获取长度
        private double micronRatio = 1;

        //标志
        public mic_rulers xmlSaveModel;//存储标尺信息（xml或者预览拍摄选中标尺）
        /// <summary>
        /// 换算完的标尺信息，包含所有系统内得单位
        /// </summary>
        public Dictionary<MeasurementUnit, double> rules = new Dictionary<MeasurementUnit, double>();
        /// <summary>
        /// AxioVision标尺单位对应
        /// </summary>
        public Dictionary<int, MeasurementUnit> rule = new Dictionary<int, MeasurementUnit>() { { 76, MeasurementUnit.Micron }, { 75, MeasurementUnit.Millimeter }, { 74, MeasurementUnit.Centimeter }, { 77, MeasurementUnit.Nano }, { 81, MeasurementUnit.Inch }, { 84, MeasurementUnit.Mil } };

        public RulerPainter()
        {
            InitRulerInfo();
        }

        private void InitRulerInfo()
        {
            //Startup.instance.InitRulerInfo();

            this.rulerModel = Startup.instance.rulerModel;

            this.xmlSaveModel = Startup.instance.ruleDB;

            List<mic_rulers> mic_rulersAll = new List<mic_rulers>();
            if (this.xmlSaveModel == null && mic_rulersAll.Count > 0)
                this.xmlSaveModel = mic_rulersAll[0];
            this.rules.Clear();
            if (this.xmlSaveModel != null && this.xmlSaveModel.pixel_length != 0)
            {
                //计算单位长度 比如0.05英寸/像素； 100纳米/像素；
                double unitLength = (double)(this.xmlSaveModel.physical_length / (decimal)this.xmlSaveModel.pixel_length);
                switch (this.xmlSaveModel.ruler_units)
                {
                    case (int)MeasurementUnit.Inch://英寸
                        this.rules.Add(MeasurementUnit.Inch, unitLength);                    //英寸
                        this.rules.Add(MeasurementUnit.Mil, 1000 * unitLength);              //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, 2.54 * unitLength);       //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, 25.4 * unitLength);       //毫米
                        this.rules.Add(MeasurementUnit.Micron, 25400 * unitLength);          //微米
                        this.rules.Add(MeasurementUnit.Nano, 25400000 * unitLength);         //纳米
                        break;
                    case (int)MeasurementUnit.Mil://米尔
                        this.rules.Add(MeasurementUnit.Inch, 0.001 * unitLength);            //英寸
                        this.rules.Add(MeasurementUnit.Mil, unitLength);                     //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, 0.00254 * unitLength);    //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, 0.0254 * unitLength);     //毫米
                        this.rules.Add(MeasurementUnit.Micron, 25.4 * unitLength);           //微米
                        this.rules.Add(MeasurementUnit.Nano, 25400 * unitLength);            //纳米
                        break;
                    case (int)MeasurementUnit.Centimeter://厘米
                        this.rules.Add(MeasurementUnit.Inch, 0.3937008 * unitLength);        //英寸
                        this.rules.Add(MeasurementUnit.Mil, 393.7008 * unitLength);          //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, unitLength);              //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, 10 * unitLength);         //毫米
                        this.rules.Add(MeasurementUnit.Micron, 10000 * unitLength);          //微米
                        this.rules.Add(MeasurementUnit.Nano, 10000000 * unitLength);         //纳米
                        break;
                    case (int)MeasurementUnit.Millimeter://毫米
                        this.rules.Add(MeasurementUnit.Inch, 0.0393701 * unitLength);        //英寸
                        this.rules.Add(MeasurementUnit.Mil, 39.3701 * unitLength);           //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, 0.1 * unitLength);        //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, unitLength);              //毫米
                        this.rules.Add(MeasurementUnit.Micron, 1000 * unitLength);           //微米
                        this.rules.Add(MeasurementUnit.Nano, 1000000 * unitLength);          //纳米
                        break;
                    case (int)MeasurementUnit.Micron://微米
                        this.rules.Add(MeasurementUnit.Inch, 0.00003937007874 * unitLength);        //英寸
                        this.rules.Add(MeasurementUnit.Mil, 0.03937007874 * unitLength);        //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, 0.0001 * unitLength);     //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, 0.001 * unitLength);      //毫米
                        this.rules.Add(MeasurementUnit.Micron, unitLength);                  //微米
                        this.rules.Add(MeasurementUnit.Nano, 1000 * unitLength);             //纳米
                        break;
                    case (int)MeasurementUnit.Nano://纳米
                        this.rules.Add(MeasurementUnit.Inch, 3.9370e-8 * unitLength);        //英寸
                        this.rules.Add(MeasurementUnit.Mil, 3.9370e-5 * unitLength);        //米尔
                        this.rules.Add(MeasurementUnit.Centimeter, 1e-7 * unitLength);       //厘米
                        this.rules.Add(MeasurementUnit.Millimeter, 1e-6 * unitLength);       //毫米
                        this.rules.Add(MeasurementUnit.Micron, 0.001 * unitLength);          //微米
                        this.rules.Add(MeasurementUnit.Nano, unitLength);                    //纳米
                        break;
                    default:
                        this.xmlSaveModel = null;
                        break;
                }
            }
        }

        public decimal Multiple
        {
            get
            {
                return this.xmlSaveModel.gain_multiple;
            }
        }

        public decimal RulerValue
        {
            get
            {
                return this.rulerModel.autoRulerValue;
            }
        }

        /// <summary>
        /// 每像素实际单位长度
        /// </summary>
        public double MicronRatioPerPixel
        {
            get
            {
                //config.xml中RulerId必须是数据库mic_ruler中已经存在的
                var gainNumber = this.xmlSaveModel.gain_multiple;//获取放大倍数

                if (getLengthFromConfig)//判断是否从配置文件获取长度
                {
                    lineLength = Convert.ToInt32(this.rulerModel.autoRulerValue);//标尺长度 要除以放大倍数
                }

                Dictionary<MeasurementUnit, double> measurementUnitDictionary = this.rules;
                //以微米为基础单位
                double micron = measurementUnitDictionary[MeasurementUnit.Micron];//每像素多少微米长度
                double actualLineLength = (int)(lineLength / gainNumber);//除以放大倍数后的实际物理长度
                int pixelLength = Convert.ToInt32(actualLineLength / micron);//换算为像素长度

                //实际单位
                MeasurementUnit unit = MeasurementUnit.Micron;
                micronRatio = measurementUnitDictionary[unit];//每像素实际单位长度
                return micronRatio;
            }
        }

        public void DrawRuler(ref Bitmap bmp)
        {
            if (this.xmlSaveModel == null)
                return;//不能获得放大倍数

            //config.xml中RulerId必须是数据库mic_ruler中已经存在的
            var gainNumber = this.xmlSaveModel.gain_multiple;//获取放大倍数
            
            if (getLengthFromConfig)//判断是否从配置文件获取长度
            {
                lineLength = Convert.ToInt32(this.rulerModel.autoRulerValue);//标尺长度 要除以放大倍数
            }
            
            Dictionary<MeasurementUnit, double> measurementUnitDictionary = this.rules;
            //以微米为基础单位
            double micron = measurementUnitDictionary[MeasurementUnit.Micron];//每像素多少微米长度
            double actualLineLength = (int)(lineLength / gainNumber);//除以放大倍数后的实际物理长度
            int pixelLength = Convert.ToInt32(actualLineLength / micron);//换算为像素长度
            
            //实际单位
            MeasurementUnit unit = MeasurementUnit.Micron;
            micronRatio = measurementUnitDictionary[unit];//每像素实际单位长度

            string unitAbbreviation = "µm";

            SizeF windowSize = bmp.Size;//窗体尺寸

            //线样式
            Pen linePen = new Pen(Color.FromArgb(this.rulerModel.lineColor));
            linePen.Width = (int)this.rulerModel.lineWidth;

            //边框样式
            Pen borderPen = new Pen(Color.FromArgb(this.rulerModel.borderColor));
            borderPen.Width = (int)this.rulerModel.borderWidth;

            int lineWidthOffset = (int)this.rulerModel.lineWidth / 2 - 1;
            int offset = borderPen.Width > 0 ? (int)(borderPen.Width / 2) - 2 : 0;

            //背景大小
            decimal backLength = pixelLength * this.rulerModel.backgroundSize / 100;

            //垂线
            decimal verticalLength = pixelLength * this.rulerModel.verticalLineLength / 100;

            //文字
            string text = actualLineLength + unitAbbreviation;
            //string text = Math.Round(actualLineLength, MeasureDrawObject.decimalPlaces).ToString() + unitAbbreviation;//小数保留
            decimal textHeight = pixelLength * this.rulerModel.textHeight / 100;
            Font textFont = new Font(this.rulerModel.textFont, (float)this.rulerModel.textFontSize);
            int fontNewHeight = lineWidthOffset + (int)(textHeight + new Decimal(textFont.Height));

            int abc = fontNewHeight > ((int)verticalLength / 2 - 2) ? fontNewHeight : ((int)verticalLength / 2 - 2);

            //标尺最终尺寸
            int rulerWidth = pixelLength + (int)(backLength * 2) + (int)(linePen.Width * 2) + offset * 2;
            int rulerHeight = (int)verticalLength / 2 + abc + (int)(backLength * 2) + lineWidthOffset + 2 + offset * 2;

            int rulerPosition = this.rulerModel.rulerPosition;//标尺位置
            decimal rulerMargin = this.rulerModel.rulerMargin / 100;//标尺边距
            float marginLR = (float)rulerMargin * windowSize.Width;//左右边距
            float marginTB = (float)rulerMargin * windowSize.Height;//上下边距

            float offsetBorder = borderPen.Width > 0 ? borderPen.Width / 2 : 0;

            PointF startPoint = new PointF();

            switch (rulerPosition)
            {
                case 1://左上
                    startPoint.X = rulerWidth / 2f - lineWidthOffset + offsetBorder + marginLR;
                    startPoint.Y = fontNewHeight + (float)backLength - lineWidthOffset + offsetBorder + marginTB;
                    break;
                case 2://右上
                    startPoint.X = windowSize.Width - (rulerWidth / 2f - lineWidthOffset + offsetBorder) - marginLR;
                    startPoint.Y = fontNewHeight + (float)backLength - lineWidthOffset + offsetBorder + marginTB;
                    break;
                case 3://左下
                    startPoint.X = rulerWidth / 2f - lineWidthOffset + offsetBorder + marginLR;
                    startPoint.Y = windowSize.Height - (rulerHeight - (fontNewHeight + (float)backLength)) - offsetBorder - marginTB;
                    break;
                case 4://右下
                    startPoint.X = windowSize.Width - (rulerWidth / 2f - lineWidthOffset + offsetBorder) - marginLR;
                    startPoint.Y = windowSize.Height - (rulerHeight - (fontNewHeight + (float)backLength)) - offsetBorder - marginTB;
                    break;
            }

            Graphics g = Graphics.FromImage((Image)bmp);
            g.SmoothingMode = SmoothingMode.AntiAlias;

            RectangleF rectangle = new Rectangle();
            DrawRulerHelper.drawRuler(this.rulerModel, g, startPoint, pixelLength, text, out rectangle);

            g.Dispose();
        }

    }
}