Metis_xctg/GeneralAnalysis/Artwork/ArtworkPointUserControl.cs

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using Metis.ParameterSet;
using PaintDotNet.Adjust.BaseImage;
using PaintDotNet.Annotation;
using PaintDotNet.Annotation.Enum;
using PaintDotNet.Base.CommTool;
using PaintDotNet.CustomControl;

namespace PaintDotNet.GeneralAnalysis.Artwork
{
    internal partial class ArtworkPointUserControl : ArtworkUserControl
    {
        private AppWorkspace m_appWorkspace;
        private DocumentWorkspaceWindow m_artWorkspace;
        private DocumentWorkspaceWindow m_targetWorkspace;
        private Bitmap m_selectedBitmap;
        private int m_selectedIndex;
        private int m_targetPoint1X;
        private int m_targetPoint1Y;
        private int m_targetPoint2X;
        private int m_targetPoint2Y;

        private ArtworkControlButtons m_artCommonControlButtons;
        private ArtworkControlButtons m_targetCommonControlButtons;
        private void InitializeLanguageText()
        {
            this.groupBox1.Text = PdnResources.GetString("Menu.Generalanalysis.Processmparison.Targetpicture.text");
            this.label2.Text = PdnResources.GetString("Menu.transparency.text");
            this.chkLine.Text = PdnResources.GetString("Menu.Generalanalysis.Processmparison.displayauxiliarylines.text");
            this.chkGrids.Text = PdnResources.GetString("Menu.displaygrid.text");
            this.groupBox4.Text = PdnResources.GetString("Menu.Setting.Text");
            this.groupBox3.Text = PdnResources.GetString("Menu.Processdrawing.Text");
            this.groupBox2.Text = PdnResources.GetString("Menu.fixedpointtoenlargethdisplayarea.Text");
            this.groupBox5.Text = PdnResources.GetString("Menu.Generalanalysis.Processmparison.Targetgraphcontrol.text");
            this.label1.Text = PdnResources.GetString("Menu.transparency.text");
        }
        public ArtworkPointUserControl(AppWorkspace appWorkspace, int width, int height)
        {
            m_appWorkspace = appWorkspace;
            InitializeComponent();
            InitializeLanguageText();
            this.Width = width;
            this.Height = height;
            InitializeData();
            InitializeArtBaseTool();
            InitializeTargetBaseTool();
        }
        private void InitializeData()
        {
            this.m_artWorkspace = new DocumentWorkspaceWindow(m_appWorkspace);

            this.m_artWorkspace.AppWorkspaceTop = m_appWorkspace;
            this.m_artWorkspace.Visible = true;
            this.m_artWorkspace.Dock = DockStyle.Fill;
            this.pnlArt.Controls.Add(this.m_artWorkspace);
            this.m_artWorkspace.GraphicsList.SelectChanged += ArtGraphicsList_SelectChanged;

            this.m_targetWorkspace = new DocumentWorkspaceWindow(m_appWorkspace);
            this.m_targetWorkspace.AppWorkspaceTop = m_appWorkspace;
            this.m_targetWorkspace.Visible = true;
            this.m_targetWorkspace.Dock = DockStyle.Fill;
            this.pnlTarget.Controls.Add(this.m_targetWorkspace);
            this.m_targetWorkspace.GraphicsList.SelectChanged += TargetGraphicsList_SelectChanged;

            Init();
        }

        #region 初始化基础工具

        /// <summary>
        /// 初始化基础工具
        /// </summary>
        public void InitializeTargetBaseTool()
        {

            this.m_targetCommonControlButtons = new ArtworkControlButtons();
            this.m_targetCommonControlButtons.Dock = DockStyle.Top;
            this.m_targetCommonControlButtons.Height = 30;
            this.pnlTargetTools.Controls.Add(m_targetCommonControlButtons);

            this.m_targetCommonControlButtons.zoomInButton.Click += new EventHandler(zoomInButtonTarget_Click);
            this.m_targetCommonControlButtons.zoomOutButton.Click += new EventHandler(zoomOutButtonTarget_Click);
            this.m_targetCommonControlButtons.zoomToWindowButton.Click += new EventHandler(zoomToWindowButtonTarget_Click);
            this.m_targetCommonControlButtons.actualSizeButton.Click += new EventHandler(actualSizeButtonTarget_Click);
            this.m_targetCommonControlButtons.pointerButton.Click += new EventHandler(pointerButtonTarget_Click);
            this.m_targetCommonControlButtons.mobileModeButton.Click += new EventHandler(mobileModeButtonTarget_Click);
            this.m_targetCommonControlButtons.moveUpButton.Click += new EventHandler(moveUpButtonTarget_Click);
            this.m_targetCommonControlButtons.moveDownButton.Click += new EventHandler(moveDownButtonTarget_Click);
            this.m_targetCommonControlButtons.moveLeftButton.Click += new EventHandler(moveLeftButtonTarget_Click);
            this.m_targetCommonControlButtons.moveRightButton.Click += new EventHandler(moveRightButtonTarget_Click);
        }

        private void moveUpButtonTarget_Click(object sender, EventArgs e)
        {
            if (this.m_targetWorkspace.CompositionSurface != null)
            {
                for (int i = 0; i < this.m_targetWorkspace.GraphicsList.Count; i++)
                {
                    if (this.m_targetWorkspace.GraphicsList[i].Selected)
                    {
                        RectangleF rectangleF = this.m_targetWorkspace.GraphicsList[i].Rectangle;
                        this.m_targetWorkspace.GraphicsList[i].Rectangle = new RectangleF(rectangleF.X, rectangleF.Y - 1, rectangleF.Width, rectangleF.Height);
                        this.m_targetWorkspace.Refresh();
                        return;
                    }
                }
            }
        }
        private void moveDownButtonTarget_Click(object sender, EventArgs e)
        {
            if (this.m_targetWorkspace.CompositionSurface != null)
            {
                for (int i = 0; i < this.m_targetWorkspace.GraphicsList.Count; i++)
                {
                    if (this.m_targetWorkspace.GraphicsList[i].Selected)
                    {
                        RectangleF rectangleF = this.m_targetWorkspace.GraphicsList[i].Rectangle;
                        this.m_targetWorkspace.GraphicsList[i].Rectangle = new RectangleF(rectangleF.X, rectangleF.Y + 1, rectangleF.Width, rectangleF.Height);
                        this.m_targetWorkspace.Refresh();
                        return;
                    }
                }
            }
        }
        private void moveLeftButtonTarget_Click(object sender, EventArgs e)
        {
            if (this.m_targetWorkspace.CompositionSurface != null)
            {
                for (int i = 0; i < this.m_targetWorkspace.GraphicsList.Count; i++)
                {
                    if (this.m_targetWorkspace.GraphicsList[i].Selected)
                    {
                        RectangleF rectangleF = this.m_targetWorkspace.GraphicsList[i].Rectangle;
                        this.m_targetWorkspace.GraphicsList[i].Rectangle = new RectangleF(rectangleF.X - 1, rectangleF.Y, rectangleF.Width, rectangleF.Height);
                        this.m_targetWorkspace.Refresh();
                        return;
                    }
                }
            }
        }
        private void moveRightButtonTarget_Click(object sender, EventArgs e)
        {
            if (this.m_targetWorkspace.CompositionSurface != null)
            {
                for (int i = 0; i < this.m_targetWorkspace.GraphicsList.Count; i++)
                {
                    if (this.m_targetWorkspace.GraphicsList[i].Selected)
                    {
                        RectangleF rectangleF = this.m_targetWorkspace.GraphicsList[i].Rectangle;
                        this.m_targetWorkspace.GraphicsList[i].Rectangle = new RectangleF(rectangleF.X + 1, rectangleF.Y, rectangleF.Width, rectangleF.Height);
                        this.m_targetWorkspace.Refresh();
                        return;
                    }
                }
            }
        }

        private void mobileModeButtonTarget_Click(object sender, EventArgs e)
        {
            this.m_targetWorkspace.ActiveTool = Annotation.Enum.DrawToolType.MoveMode;
        }

        private void pointerButtonTarget_Click(object sender, EventArgs e)
        {
            this.m_targetWorkspace.ActiveTool = Annotation.Enum.DrawToolType.Pointer;
        }

        private void zoomToWindowButtonTarget_Click(object sender, EventArgs e)
        {
            if (this.m_targetWorkspace.CompositionSurface != null)
            {
                this.m_targetWorkspace.ZoomToWindow();
            }
        }

        private void actualSizeButtonTarget_Click(object sender, EventArgs e)
        {
            if (this.m_targetWorkspace.CompositionSurface != null)
            {
                this.m_targetWorkspace.ZoomBasis = ZoomBasis.ScaleFactor;
                this.m_targetWorkspace.ScaleFactor = ScaleFactor.OneToOne;
            }
        }

        private void zoomOutButtonTarget_Click(object sender, EventArgs e)
        {
            if (this.m_targetWorkspace.CompositionSurface != null)
                this.m_targetWorkspace.ZoomOut();
        }

        private void zoomInButtonTarget_Click(object sender, EventArgs e)
        {
            if (this.m_targetWorkspace.CompositionSurface != null)
                this.m_targetWorkspace.ZoomIn();
        }

        public void InitializeArtBaseTool()
        {
            this.m_artCommonControlButtons = new ArtworkControlButtons();
            this.m_artCommonControlButtons.Dock = DockStyle.Top;
            this.m_artCommonControlButtons.Height = 30;
            this.pnlArtTools.Controls.Add(m_artCommonControlButtons);

            this.m_artCommonControlButtons.zoomInButton.Click += new EventHandler(zoomInButton_Click);
            this.m_artCommonControlButtons.zoomOutButton.Click += new EventHandler(zoomOutButton_Click);
            this.m_artCommonControlButtons.zoomToWindowButton.Click += new EventHandler(zoomToWindowButton_Click);
            this.m_artCommonControlButtons.actualSizeButton.Click += new EventHandler(actualSizeButton_Click);
            this.m_artCommonControlButtons.pointerButton.Click += new EventHandler(pointerButton_Click);
            this.m_artCommonControlButtons.mobileModeButton.Click += new EventHandler(mobileModeButton_Click);
            this.m_artCommonControlButtons.moveUpButton.Click += new EventHandler(moveUpButton_Click);
            this.m_artCommonControlButtons.moveDownButton.Click += new EventHandler(moveDownButton_Click);
            this.m_artCommonControlButtons.moveLeftButton.Click += new EventHandler(moveLeftButton_Click);
            this.m_artCommonControlButtons.moveRightButton.Click += new EventHandler(moveRightButton_Click);
        }
        private void moveUpButton_Click(object sender, EventArgs e)
        {
            if (this.m_artWorkspace.CompositionSurface != null)
            {
                for (int i = 0; i < this.m_artWorkspace.GraphicsList.Count; i++)
                {
                    if (this.m_artWorkspace.GraphicsList[i].Selected)
                    {
                        RectangleF rectangleF = this.m_artWorkspace.GraphicsList[i].Rectangle;
                        this.m_artWorkspace.GraphicsList[i].Rectangle = new RectangleF(rectangleF.X, rectangleF.Y - 1, rectangleF.Width, rectangleF.Height);
                        this.m_artWorkspace.Refresh();
                        return;
                    }
                }
            }
        }
        private void moveDownButton_Click(object sender, EventArgs e)
        {
            if (this.m_artWorkspace.CompositionSurface != null)
            {
                for (int i = 0; i < this.m_artWorkspace.GraphicsList.Count; i++)
                {
                    if (this.m_artWorkspace.GraphicsList[i].Selected)
                    {
                        RectangleF rectangleF = this.m_artWorkspace.GraphicsList[i].Rectangle;
                        this.m_artWorkspace.GraphicsList[i].Rectangle = new RectangleF(rectangleF.X, rectangleF.Y + 1, rectangleF.Width, rectangleF.Height);
                        this.m_artWorkspace.Refresh();
                        return;
                    }
                }
            }
        }
        private void moveLeftButton_Click(object sender, EventArgs e)
        {
            if (this.m_artWorkspace.CompositionSurface != null)
            {
                for (int i = 0; i < this.m_artWorkspace.GraphicsList.Count; i++)
                {
                    if (this.m_artWorkspace.GraphicsList[i].Selected)
                    {
                        RectangleF rectangleF = this.m_artWorkspace.GraphicsList[i].Rectangle;
                        this.m_artWorkspace.GraphicsList[i].Rectangle = new RectangleF(rectangleF.X - 1, rectangleF.Y, rectangleF.Width, rectangleF.Height);
                        this.m_artWorkspace.Refresh();
                        return;
                    }
                }
            }
        }
        private void moveRightButton_Click(object sender, EventArgs e)
        {
            if (this.m_artWorkspace.CompositionSurface != null)
            {
                for (int i = 0; i < this.m_artWorkspace.GraphicsList.Count; i++)
                {
                    if (this.m_artWorkspace.GraphicsList[i].Selected)
                    {
                        RectangleF rectangleF = this.m_artWorkspace.GraphicsList[i].Rectangle;
                        this.m_artWorkspace.GraphicsList[i].Rectangle = new RectangleF(rectangleF.X + 1, rectangleF.Y, rectangleF.Width, rectangleF.Height);
                        this.m_artWorkspace.Refresh();
                        return;
                    }
                }
            }
        }

        private void mobileModeButton_Click(object sender, EventArgs e)
        {
            this.m_artWorkspace.ActiveTool = Annotation.Enum.DrawToolType.MoveMode;
        }

        private void pointerButton_Click(object sender, EventArgs e)
        {
            this.m_artWorkspace.ActiveTool = Annotation.Enum.DrawToolType.Pointer;
        }

        private void zoomToWindowButton_Click(object sender, EventArgs e)
        {
            if (this.m_artWorkspace.CompositionSurface != null)
            {
                this.m_artWorkspace.ZoomToWindow();
            }
        }

        private void actualSizeButton_Click(object sender, EventArgs e)
        {
            if (this.m_artWorkspace.CompositionSurface != null)
            {
                this.m_artWorkspace.ZoomBasis = ZoomBasis.ScaleFactor;
                this.m_artWorkspace.ScaleFactor = ScaleFactor.OneToOne;
            }
        }

        private void zoomOutButton_Click(object sender, EventArgs e)
        {
            if (this.m_artWorkspace.CompositionSurface != null)
                this.m_artWorkspace.ZoomOut();
        }

        private void zoomInButton_Click(object sender, EventArgs e)
        {
            if (this.m_artWorkspace.CompositionSurface != null)
                this.m_artWorkspace.ZoomIn();
        }

        #endregion

        private Rectangle m_cropRectangle;

        public void getData(GeneralAnalysisModel.ArtworkComparativeModel artworkComparativeModel)
        {
            this.chkGrids.Checked = artworkComparativeModel.parameter2;
            this.chkLine.Checked = artworkComparativeModel.parameter3;
            this.trbArt.Value = artworkComparativeModel.parameter4;
            this.txtArtTrbValue.Text = artworkComparativeModel.parameter4.ToString();
            this.trbTarget.Value = artworkComparativeModel.parameter6;
            this.txtTargetTrbValue.Text = artworkComparativeModel.parameter6.ToString();
        }

        public GeneralAnalysisModel.ArtworkComparativeModel saveData()
        {
            var artworkComparativeModel = new GeneralAnalysisModel.ArtworkComparativeModel();

            artworkComparativeModel.parameter2 = this.chkGrids.Checked;
            artworkComparativeModel.parameter3 = this.chkLine.Checked;
            artworkComparativeModel.parameter4 = this.trbArt.Value;
            artworkComparativeModel.parameter6 = this.trbTarget.Value;
 
            return artworkComparativeModel;
        }

        private void ArtGraphicsList_SelectChanged(object sender, EventArgs e)
        {
            GraphicsList graphicsList = (GraphicsList)sender;
            if (graphicsList.Count < 2)
            {
                return;
            }
            for (int i = 0; i < graphicsList.Count; i++)
            {
                RectangleF rectangle = graphicsList[i].GetBoundingBox();

                if (((DrawObject)graphicsList[i]).ID == 1)
                {
                    Artwork.point2X = (int)rectangle.X + Artwork.side / 2;
                    Artwork.point2Y = (int)rectangle.Y + Artwork.side / 2;
                }
                else
                {
                    Artwork.point1X = (int)rectangle.X + Artwork.side / 2;
                    Artwork.point1Y = (int)rectangle.Y + Artwork.side / 2;
                }
                if (graphicsList[i].Selected)
                {
                    m_selectedIndex = ((DrawObject)graphicsList[i]).ID;
                    m_cropRectangle = Rectangle.Ceiling(rectangle);
                    m_selectedBitmap = ImageTools.Crop(this.ArtBitmap, m_cropRectangle);
                    picSelected.Image = m_selectedBitmap;

                    if(this.m_targetWorkspace.GraphicsList.GetDrawClassList(DrawClass.Label).Count > m_selectedIndex)
                    {
                        rectangle = this.m_targetWorkspace.GraphicsList[i].GetBoundingBox();
                        this.m_targetWorkspace.SetSelectedBitmap(m_selectedBitmap, rectangle);
                    }

                    
                }
            }
        }

        private void TargetGraphicsList_SelectChanged(object sender, EventArgs e)
        {
            GraphicsList graphicsList = (GraphicsList)sender;
            if (graphicsList.Count < 2)
            {
                return;
            }
            for (int i = 0; i < graphicsList.Count; i++)
            {
                RectangleF rectangle = graphicsList[i].GetBoundingBox();
                if (((DrawObject)graphicsList[i]).ID == 1)
                {
                    m_targetPoint2X = (int)rectangle.X + Artwork.side / 2;
                    m_targetPoint2Y = (int)rectangle.Y + Artwork.side / 2;
                }
                else
                {
                    m_targetPoint1X = (int)rectangle.X + Artwork.side / 2;
                    m_targetPoint1Y = (int)rectangle.Y + Artwork.side / 2;
                }
                if (graphicsList[i].Selected)
                {
                    if (m_selectedIndex == ((DrawObject)graphicsList[i]).ID)
                    {
                        this.m_targetWorkspace.SetSelectedBitmap(m_selectedBitmap, rectangle);
                    }
                }
            }
        }

        public override void Init()
        {
            if (this.ArtBitmap != null)
            {
                this.chkGrids.Checked = this.GridLineEnabled;
                this.chkLine.Checked = this.AuxiliaryLineEnabled;
                this.trbArt.Value = this.Transparency;

                Document document = Document.FromImage(this.ArtBitmap);
                this.m_artWorkspace.Document = document;

                //Artwork = Startup.instance.artworkModel.items[m_selectIndex];

                if (Artwork != null)
                {
                    if (this.m_artWorkspace.GraphicsList.Count != 2 || ArtChanged)
                    {
                        this.ArtChanged = false;
                        this.m_artWorkspace.GraphicsList.Clear();
                        // 加载两点的方形
                        Pen pen1 = new Pen(ColorTranslator.FromHtml(Artwork.point1Color), Artwork.lineWidth);
                        Rectangle rectangle1 = new Rectangle(Artwork.point1X - Artwork.side / 2, Artwork.point1Y - Artwork.side / 2, Artwork.side, Artwork.side);
                        this.m_artWorkspace.ActiveTool = DrawToolType.DrawArtworkRectangle;
                        this.m_artWorkspace.CreateArtworkRectangle(0, pen1, rectangle1);
                        Pen pen2 = new Pen(ColorTranslator.FromHtml(Artwork.point2Color), Artwork.lineWidth);
                        Rectangle rectangle2 = new Rectangle(Artwork.point2X - Artwork.side / 2, Artwork.point2Y - Artwork.side / 2, Artwork.side, Artwork.side);
                        this.m_artWorkspace.ActiveTool = DrawToolType.DrawArtworkRectangle;
                        this.m_artWorkspace.CreateArtworkRectangle(1, pen2, rectangle2);
                    }

                }

            }
            if (this.TargetBitmap != null)
            {
                this.trbTarget.Value = this.TargetTransparency;

                Document document = Document.FromImage(this.TargetBitmap);
                this.m_targetWorkspace.Document = document;

                if (Artwork != null) //
                {
                    if (this.m_targetWorkspace.GraphicsList.Count != 2 || ArtChanged)
                    {
                        this.m_targetWorkspace.GraphicsList.Clear();
                        // 加载两点的方形
                        Pen pen1 = new Pen(ColorTranslator.FromHtml(Artwork.point1Color), Artwork.lineWidth);
                        Rectangle rectangle1 = new Rectangle(Artwork.point1X - Artwork.side / 2, Artwork.point1Y - Artwork.side / 2, Artwork.side, Artwork.side);
                        this.m_targetWorkspace.ActiveTool = DrawToolType.DrawArtworkRectangle;
                        this.m_targetWorkspace.CreateArtworkRectangle(0, pen1, rectangle1);
                        Pen pen2 = new Pen(ColorTranslator.FromHtml(Artwork.point2Color), Artwork.lineWidth);
                        Rectangle rectangle2 = new Rectangle(Artwork.point2X - Artwork.side / 2, Artwork.point2Y - Artwork.side / 2, Artwork.side, Artwork.side);
                        this.m_targetWorkspace.ActiveTool = DrawToolType.DrawArtworkRectangle;
                        this.m_targetWorkspace.CreateArtworkRectangle(1, pen2, rectangle2);
                    }
                }
            }
        }

        private void ArtworkPointUserControl_Resize(object sender, EventArgs e)
        {
            int width = groupBox4.Location.X - groupBox3.Location.X - 6 - 6;
            groupBox3.Width = width / 2;
            groupBox3.Height = this.Height - 10;
            pnlArt.Width = groupBox3.Width - 12;
            pnlArt.Height = groupBox3.Height - 100;

            pnlArtTools.Width = groupBox3.Width - 12;
            pnlArtTools.Top = groupBox3.Height - 57;
            pnlArtTools.Left = pnlArt.Left;

            groupBox1.Location = new Point(groupBox3.Location.X + width / 2 + 6, groupBox3.Location.Y);
            groupBox1.Width = width / 2;
            groupBox1.Height = this.Height - 10;
            pnlTarget.Width = groupBox1.Width - 12;
            pnlTarget.Height = groupBox1.Height - 100;
            pnlTargetTools.Width = groupBox1.Width - 12;
            pnlTargetTools.Top = groupBox1.Height - 57;
            pnlTargetTools.Left = pnlTarget.Left;
        }

        private void chkGrids_CheckedChanged(object sender, EventArgs e)
        {
            if (this.m_artWorkspace != null)
            {
                this.m_artWorkspace.GridLineFullEnabled = !this.m_artWorkspace.GridLineFullEnabled;
                this.m_artWorkspace.Refresh();
            }
            if (this.m_targetWorkspace != null)
            {
                this.m_targetWorkspace.GridLineFullEnabled = !this.m_targetWorkspace.GridLineFullEnabled;
                this.m_targetWorkspace.Refresh();
            }

            this.GridLineEnabled = chkGrids.Checked;
        }

        private void chkLine_CheckedChanged(object sender, EventArgs e)
        {
            if (this.m_artWorkspace != null)
            {
                this.m_artWorkspace.AuxiliaryLineEnabled = !this.m_artWorkspace.AuxiliaryLineEnabled;
                this.m_artWorkspace.Refresh();
            }
            if (this.m_targetWorkspace != null)
            {
                this.m_targetWorkspace.AuxiliaryLineEnabled = !this.m_targetWorkspace.AuxiliaryLineEnabled;
                this.m_targetWorkspace.Refresh();
            }
            this.AuxiliaryLineEnabled = chkLine.Checked;
        }

        private void trbArt_ValueChanged(object sender, EventArgs e)
        {
            this.Transparency = trbArt.Value;
            if (this.ArtBitmap != null)
            {
                this.ArtBitmap = MakeTransparent(this.ArtBitmap, trbArt.Value);
                try
                {
                    m_selectedBitmap = ImageTools.Crop(this.ArtBitmap, m_cropRectangle);
                }
                catch (Exception)
                {
                    return;
                }
                picSelected.Image = m_selectedBitmap;

                if (this.m_targetWorkspace.GraphicsList.GetDrawClassList(DrawClass.Label).Count > m_selectedIndex)
                {
                    RectangleF rectangle = this.m_targetWorkspace.GraphicsList[m_selectedIndex].GetBoundingBox();
                    this.m_targetWorkspace.SetSelectedBitmap(m_selectedBitmap, rectangle);
                }

            }
            txtArtTrbValue.Text = trbArt.Value.ToString();
            
        }

        private void txtArtTrbValue_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == (char)Keys.Enter)
            {
                if (string.IsNullOrEmpty(txtArtTrbValue.Text.Trim()))
                {
                    e.Handled = true;
                    this.txtArtTrbValue.Text = "0";
                    return;
                }
                int val = Convert.ToInt32(this.txtArtTrbValue.Text);
                if (val < 0)
                {
                    val = 0;
                    this.txtArtTrbValue.Text = "0";
                }
                else if (val > 255)
                {
                    val = 255;
                    this.txtArtTrbValue.Text = "255";
                }
                trbArt.Value = val;
            }
            if (e.KeyChar != 8 && !Char.IsDigit(e.KeyChar))
            {
                e.Handled = true;
            }
        }

        private void trbTarget_ValueChanged(object sender, EventArgs e)
        {
            this.TargetTransparency = trbTarget.Value;
            if (this.TargetBitmap != null)
            {
                this.TargetBitmap = MakeTransparent(this.TargetBitmap, trbTarget.Value);

            }
            txtTargetTrbValue.Text = trbTarget.Value.ToString();
        }

        private void txtTargetTrbValue_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == (char)Keys.Enter)
            {
                if (string.IsNullOrEmpty(txtTargetTrbValue.Text.Trim()))
                {
                    e.Handled = true;
                    this.txtTargetTrbValue.Text = "0";
                    return;
                }
                int val = Convert.ToInt32(this.txtTargetTrbValue.Text);
                if (val < 0)
                {
                    val = 0;
                    this.txtTargetTrbValue.Text = "0";
                }
                else if (val > 255)
                {
                    val = 255;
                    this.txtTargetTrbValue.Text = "255";
                }
                trbTarget.Value = val;
            }
            if (e.KeyChar != 8 && !Char.IsDigit(e.KeyChar))
            {
                e.Handled = true;
            }
        }

        

        private double TargetRotate()
        {
            double angleOfArt = Math.Atan2((Artwork.point2Y - Artwork.point1Y), (Artwork.point2X - Artwork.point1X)) * 180 / Math.PI;
            double angleOfTarget = Math.Atan2((m_targetPoint2Y - m_targetPoint1Y), (m_targetPoint2X - m_targetPoint1X)) * 180 / Math.PI;
            return angleOfTarget - angleOfArt;
        }

        /// <summary>
        /// 工艺图比照，定位插入，保存图片
        /// </summary>
        public void Save()
        {
            float angle = (float)TargetRotate();
            double distanceArt = ImageTools.CalcDistance(new Point(Artwork.point1X, Artwork.point1Y), new Point(Artwork.point2X, Artwork.point2Y));
            double distanceTarget = ImageTools.CalcDistance(new Point(m_targetPoint1X, m_targetPoint1Y), new Point(m_targetPoint2X, m_targetPoint2Y));
            
            //旋转图片
            OpenCvSharp.Mat targetMat = PaintDotNet.Camera.Tools.ToMat(this.TargetBitmap);
            BaseTools.ImageRotate(targetMat, targetMat, -angle, OpenCvSharp.InterpolationFlags.Linear);

            
            //计算绘制的左上角的坐标点
            //计算旋转后的点
            Matrix matrix = new Matrix();
            matrix.RotateAt((float)-angle, new Point(this.TargetBitmap.Width/2, this.TargetBitmap.Height / 2));
            Point[] ff = new Point[2];
            ff[0] = new Point(m_targetPoint1X, m_targetPoint1Y);
            ff[1] = new Point(m_targetPoint2X, m_targetPoint2Y);
            matrix.TransformPoints(ff);
            matrix.Dispose();
            matrix = null;

            //缩放点
            int xcha = (targetMat.Width - this.TargetBitmap.Width)/ 2;
            int ycha = (targetMat.Height - this.TargetBitmap.Height) / 2;

            OpenCvSharp.Point new1 = new OpenCvSharp.Point(ff[0].X  + xcha, ff[0].Y  + ycha);
            OpenCvSharp.Point new2 = new OpenCvSharp.Point(ff[1].X  + xcha, ff[1].Y  + ycha);

            /*OpenCvSharp.Cv2.Circle(targetMat, new1, 2, new OpenCvSharp.Scalar(0, 255, 0));
            OpenCvSharp.Cv2.Circle(targetMat, new2, 2, new OpenCvSharp.Scalar(0, 0, 255));
            OpenCvSharp.Cv2.ImShow("11", targetMat);*/

            //缩放图片
            double scale = distanceArt / distanceTarget;
            OpenCvSharp.Cv2.Resize(targetMat, targetMat, new OpenCvSharp.Size(targetMat.Width* scale, targetMat.Height*scale));

            OpenCvSharp.Point new11 = new OpenCvSharp.Point(new1.X * scale, new1.Y * scale);
            OpenCvSharp.Point new22 = new OpenCvSharp.Point(new2.X * scale, new2.Y * scale);

            /*OpenCvSharp.Cv2.Circle(targetMat, new11, 2, new OpenCvSharp.Scalar(0, 255, 0));
            OpenCvSharp.Cv2.Circle(targetMat, new22, 2, new OpenCvSharp.Scalar(0, 0, 255));
            OpenCvSharp.Cv2.ImShow("22", targetMat);*/

            //计算绘制位置位置
            //获取相对两个点的左上角的点
            Point targetleftTopTemp = new Point(new11.X < new22.X ? new11.X : new22.X, new11.Y < new22.Y ? new11.Y : new22.Y);
            Point artleftTopTemp = new Point(Artwork.point1X < Artwork.point2X ? Artwork.point1X : Artwork.point2X,
                Artwork.point1Y < Artwork.point2Y ? Artwork.point1Y : Artwork.point2Y);
            Point drawPoint = new Point(artleftTopTemp.X - targetleftTopTemp.X, artleftTopTemp.Y - targetleftTopTemp.Y);


            // 2020091 edit
            //Bitmap temp = (Bitmap)this.ArtBitmap.Clone();
            Bitmap temp = new Bitmap(this.ArtBitmap.Width, this.ArtBitmap.Height);
            Graphics graphics = Graphics.FromImage(temp);
            graphics.DrawImage(OpenCvSharp.Extensions.BitmapConverter.ToBitmap(targetMat), drawPoint.X, drawPoint.Y, targetMat.Width, targetMat.Height);
            //OpenCvSharp.Cv2.ImShow("22", PaintDotNet.Camera.Tools.ToMat(temp));


            this.TargetBitmap = temp;
            

            // end edit

            //DocumentWorkspace dw = m_appWorkspace.AddNewDocumentWorkspace();
            //Document document = Document.FromImage(temp);
            //document.Dirty = true;
            //dw.Document = document;
            ////激活
            //m_appWorkspace.ActiveDocumentWorkspace = dw;
            ////锁定扩缩
            //if (m_appWorkspace.isLockZoom && m_appWorkspace.lockScaleRatio > 0)
            //{
            //    m_appWorkspace.ActiveDocumentWorkspace.ZoomBasis = ZoomBasis.ScaleFactor;
            //    m_appWorkspace.ActiveDocumentWorkspace.ScaleFactor = ScaleFactor.FromDouble(m_appWorkspace.lockScaleRatio);
            //    m_appWorkspace.SetZoonTrackValue(m_appWorkspace.ActiveDocumentWorkspace.ScaleFactor);
            //}
            //else
            //{
            //    m_appWorkspace.ActiveDocumentWorkspace.ZoomBasis = ZoomBasis.FitToWindow;
            //}
            //m_appWorkspace.Refresh();

        }

        
    }
}