Tuo Wenbo / WeiQ_Mianfang

using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using OS.Spin.ViewModle.Models;
using OS.Spin.View.Utils;
using OS.Spin.ViewModle.Flaw;
using OS.Spin.Common;
using OS.Spin.View.Windows;
using OS.Spin.Modle.BusinessLayer;
using System.Windows.Input;

namespace OS.Spin.View.MainWindowControls
{
    /// <summary>
    /// UserControlOne.xaml 的交互逻辑
    /// </summary>
    public partial class UserControlOne : UserControl
    {
        public UserControlOne()
        {
            InitializeComponent();
        }
        /// <summary>
        /// 添加瑕疵点数据
        /// </summary>
        /// <param name="image"></param>
        public void addDefectMap(ImageData image)
        {
            if (image != null)
            {
                label.addImageData(image);
            }
        }

        /// <summary>
        /// 控制瑕疵点选择态和非选择态之间的转换
        /// </summary>
        /// <param name="image"></param>
        public void changeDefectMap(ImageData image)
        {
            try
            {
                //1、获取图片数据集合
                List<ImageData> data = label.GetImageDatas();
                //2、该点在图片数据集合中是否存在(若存在则转换,不存在则返回)
                int a = 0;
                for (int i = 0; i < data.Count; i++)     //操纵图片数据list集合
                {
                    if (a == 1)  //找到就直接退出
                    {
                        continue;
                    }
                    ImageData imageData = data[i];
                    if (imageData.StartX == image.StartX && imageData.StartY == image.StartY)   //此图标在集合中存在
                    {
                        a = 1;
                        //如果这个点存在则改变它的状态
                        if (imageData.Choice == 0)
                        {
                            imageData.Type = 2;
                            imageData.Choice = 1;
                        }
                        else if (imageData.Choice == 1)
                        {
                            imageData.Type = 1;
                            imageData.Choice = 0;
                        }
                    }
                }
                //3、重新加载最新的数据
                addLable(label.getListObject().Count);
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("changeDefectMap:{0}", ex.Message));
            }
        }

        /// <summary>
        /// 默认初始化瑕疵点是选择态还是非选择态
        /// </summary>
        /// <param name="choice"></param>
        public void showDefectMap(int choice)
        {
            try
            {
                //获取图标数据集合
                List<ImageData> imageDatas = label.GetImageDatas();
                if (imageDatas.Count == 0 || imageDatas == null)
                {
                    return;
                }
                //获取控件的实际高度和宽度
                int width = (int)addLabel.ActualWidth;  //该Canvas控件的实际宽度
                int height = (int)addLabel.ActualHeight;    //该Canvas控件的实际高度
                LabelData labelData = label.getLabelData();     //存放标签刻度的JavaBean
                int start = labelData.Start;    //刻度起始值
                int end = labelData.End;     //刻度终止值
                int number = label.getListObject().Count;
                int addNumber = (end - start) / (number - 1);    //标签的间隔数值
                                                                 //double space = (double)height / number;    //每一间隔所对应的纵坐标值
                                                                 //新添加的逻辑
                double reallyInterval = (double)(998 - 69) / (number - 1);  //实际标签之间的间隔百分比
                double reallyLeftInterval = (double)18 / 469;   //标签左边实际间隔百分比

                double userControlX = (double)reallyLeftInterval * width;   //实际起始横坐标
                double userControlY = (double)69 / 1066 * height;    //实际起始纵坐标
                                                                     //标签实际间隔
                double space = (double)(reallyInterval / 1066) * height;
                //1、将前面的选择态置为非选择，或是将非选择置为选择
                if (choice == 0)    //将状态置为选择1
                {
                    for (int i = 0; i < imageDatas.Count; i++)
                    {
                        imageDatas[i].Type = 1;
                        imageDatas[i].Choice = 0;
                        //如果是1直接显示圆(表示选择态)
                        double pWidth = imageDatas[i].StartX;
                        double pHeight = imageDatas[i].StartY;
                        if (pWidth > 2.2 || pHeight > end || pHeight < start)
                        {
                            continue;
                        }
                        //根据该瑕疵点的长度和宽度计算点的位置
                        //double x = pWidth * width / 2.2 ;    //横坐标
                        //double y = (pHeight - start) / addNumber * space ;   //纵坐标
                        UserControlReal userControlReal = new UserControlReal();
                        FlawsView.Children.Add(userControlReal);
                        //Canvas.SetLeft(userControlReal, x);    //这里可能还要做数据的转换
                        //Canvas.SetTop(userControlReal, y);    //比如米数和坐标系对应距离的转换
                        Canvas.SetLeft(userControlReal, GetReallyX(pWidth, true));
                        Canvas.SetTop(userControlReal, GetReallyY(pHeight, true));
                    }
                }
                else if (choice == 1)   //将状态置为选择2
                {
                    for (int i = 0; i < imageDatas.Count; i++)
                    {
                        imageDatas[i].Type = 2;
                        imageDatas[i].Choice = 1;
                        double pWidth = imageDatas[i].StartX;
                        double pHeight = imageDatas[i].StartY;
                        if (pWidth > 2.2 || pHeight > end || pHeight < start)
                        {
                            continue;
                        }
                        //根据该瑕疵点的长度和宽度计算点的位置
                        //double x = pWidth * width / 2.2 -5;    //横坐标
                        //double y = (pHeight - start) / addNumber * space ;   //纵坐标
                        UserControlEmpty userControlEmpty = new UserControlEmpty();
                        FlawsView.Children.Add(userControlEmpty);
                        //Canvas.SetLeft(userControlEmpty, x);
                        //Canvas.SetTop(userControlEmpty, y);
                        Canvas.SetLeft(userControlEmpty, GetReallyX(pWidth));
                        Canvas.SetTop(userControlEmpty, GetReallyY(pHeight));
                    }
                    //如果是2直接显示(表示非选择态)
                }
                else
                {
                    return;
                }
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("showDefectMap:{0}", ex.Message));
            }
        }

        /// <summary>
        /// 获取非选择态瑕疵点集合
        /// </summary>
        /// <returns></returns>
        public List<ImageData> getNonChoiceImageData()
        {
            try
            {
                List<ImageData> images = label.GetImageDatas();
                List<ImageData> nonChoice = new List<ImageData>();
                for (int i = 0; i < images.Count; i++)
                {
                    if (images[i].Choice == 0)
                    {
                        nonChoice.Add(images[i]);
                    }
                }
                if (nonChoice != null && nonChoice.Count > 0)
                {
                    return nonChoice;
                }
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("getNonChoiceImageData:{0}", ex.Message));
            }
            return null;
        }

        /// <summary>
        /// 获取选择态瑕疵点集合
        /// </summary>
        /// <returns></returns>
        public List<ImageData> getChoiceImageData()
        {
            try
            {
                List<ImageData> imageDatas = label.GetImageDatas();
                List<ImageData> nonChioce = getNonChoiceImageData();
                if (nonChioce != null && nonChioce.Count > 0)
                {
                    for (int i = 0; i < nonChioce.Count; i++)
                    {
                        imageDatas.Remove(nonChioce[i]);
                    }

                }
                return imageDatas;
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("getChoiceImageData:{0}", ex.Message));
                return null;
            }
        }

        /// <summary>
        /// 删除所有瑕疵点数据
        /// </summary>
        public void clearImage()
        {
            try
            {
                int width = (int)this.Width;    //窗体的宽度(用户计算点的坐标)
                int height = (int)this.Height;  //窗体的高度(用于计算子控件的坐标和间距)
                int userControlX = 0;   //子控件的横坐标
                int userControlY = 0;   //子控件的纵坐标

                //你这里内存确实清空了，但是界面并没有清空
                label.clearImageData(); //清空图片数据
                                        //清空界面
                addLabel.Children.Clear();
                FlawsView.Children.Clear();
                //重新加载Label和刻度值
                LabelData data = label.getLabelData();  //获取起始值和终值
                int start = data.Start;
                int end = data.End;

                //获取标签集
                List<UserControl1> list = label.getListObject();
                //添加标签
                int space = height / list.Count;    //设置均值和标签高度
                int num = (end - start) / list.Count;
                for (var i = 0; i < list.Count; i++)
                {
                    start += num;
                    //UserControl1 userControl = new UserControl1();
                    list[i].Height = space;
                    list[i].Width = width;
                    addLabel.Children.Add(list[i]);
                    //label.addLabels(userControl); //这里看一下是否还需要重新添加到内存中
                    list[i].LableText.runtimes = start;
                    //设置用户控件在Canvas中的位置
                    Canvas.SetLeft(list[i], userControlX);
                    Canvas.SetTop(list[i], userControlY);
                    userControlY += space;
                }
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("clearImage:{0}", ex.Message));
            }
        }

        /// <summary>
        /// 设置显示瑕疵点的位置，主要由以下三种：
        /// 1、只设置起点 2、只设置终点 3、既设置起点也设置终点
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        public void setUpDisPlay(double a, double b)  //比如(30,60)就只显示此区域之间的点坐标
        {
            try
            {
                //List<ImageData> images = label.GetImageDatas(); //获取图标直角坐标系中的坐标
                //List<ImageData> effect = new List<ImageData>();  //存放有效数据
                //LabelData labelData = label.getLabelData();  //获取默认设置的初始值和终止值

                ////保存本次设置数据
                //SetData setData = label.getSetData();
                //setData.Start = a;
                //setData.End = b;

                //int start = labelData.Start;    //最新设置的起始值
                //int end = labelData.End;    //最新设置的终止值
                //int number = label.getListObject().Count;   //标签个数
                //int addNumber = (end - start) / number;    //标签间隔数值
                //int width = (int)this.ActualWidth;
                //int height = (int)this.ActualHeight;
                //double userControlX = 0;   //子控件的横坐标
                //double userControlY = 0;   //子控件的纵坐标
                //                           //int number = LabelUtils.getNumbers();   //获取内存中标签的个数
                //double space = height / number;  //获取等分距离
                //                                 //输入数据合法性校验
                //if (b < start || a > end || a < start || b > end)
                //{
                //    return;
                //}
                ////1、默认情况加载当前区域的有效图片
                //if (a == 0 && b == 0)      //默认情况下就是现实当前区域的有效图片数据
                //{
                //    // LabelData labelData = label.getLabelData(); //获取最新输入的起始值和终点值
                //    //只要加载当前默认起点和终点位之间的值即可
                //    for (int i = 0; i < images.Count; i++)
                //    {
                //        ImageData data = images[i];
                //        if (data.StartY >= start && data.StartY <= end)
                //        {
                //            if (!effect.Contains(data))
                //            {
                //                effect.Add(data);
                //            }
                //        }
                //    }
                //}
                ////2、只设置起点值
                //if (a != 0 && b == 0)
                //{
                //    //这里可以假想每一匹布的总长度是固定
                //    //我这里只是控制图标在布匹上的不同范围内的显示而已
                //    //设置筛选条件
                //    for (int i = 0; i < images.Count; i++)
                //    {
                //        ImageData data = images[i];
                //        if (data.StartY >= a) //大于起点值的图像才显示
                //        {
                //            if (!effect.Contains(data))
                //            {   //如果没有该图标且满足条件就添加
                //                effect.Add(data);
                //            }
                //        }
                //    }
                //}
                ////3、只设置终点值
                //if (a == 0 && b != 0)
                //{
                //    for (int i = 0; i < images.Count; i++)
                //    {
                //        ImageData data = images[i];
                //        if (data.StartY < b)
                //        {
                //            if (!effect.Contains(data))
                //            {
                //                effect.Add(data);
                //            }
                //        }
                //    }
                //}
                ////4、设置起点值和终点值
                //if (a != 0 && b != 0)
                //{
                //    for (int i = 0; i < images.Count; i++)
                //    {
                //        ImageData data = images[i];
                //        if (data.StartY >= a && data.StartY <= b)
                //        {
                //            if (!effect.Contains(data))
                //            {
                //                effect.Add(data);
                //            }
                //        }
                //    }
                //}
                ////5、将有效数据展示出来
                ////(1)刚开始时默认加载的是设置初始值和终点值之间的图像全部显示出来
                ////所以第一步先要清理界面的数据(只清除界面上的数据而不清楚内存中的数据)
                ////显示符合条件的数据集合
                //if (effect.Count > 0)    //该区域存在图标
                //{
                //    addLabel.Children.Clear();  //清空所有的子控件
                //    FlawsView.Children.Clear();
                //    List<UserControl1> list = label.getListObject();
                //    //添加标签
                //    //double space = height / list.Count;    //标签间隔对应的纵坐标值
                //    //int num = (end - start) / list.Count;
                //    for (var i = 0; i < list.Count; i++)
                //    {
                //        start += addNumber;
                //        //UserControl1 userControl = new UserControl1();
                //        list[i].Height = space;
                //        list[i].Width = width;
                //        addLabel.Children.Add(list[i]);
                //        //label.addLabels(userControl); //这里看一下是否还需要重新添加到内存中
                //        list[i].LableText.runtimes = start;
                //        //设置用户控件在Canvas中的位置
                //        Canvas.SetLeft(list[i], userControlX);
                //        Canvas.SetTop(list[i], userControlY);
                //        userControlY += space;
                //    }
                //    //显示符合条件的该区域的图标
                //    for (var j = 0; j < effect.Count; j++)
                //    {
                //        ImageData image = effect[j];
                //        int bgin = labelData.Start;
                //        double x = image.StartX * width / 2.2;
                //        double y = (image.StartY - bgin) / addNumber * space;
                //        //double x = image.StartX * width / 2.2;    //布匹的实际宽度
                //        //double y = image.StartY * height / end;
                //        if (image.Choice == 0)  //选择
                //        {
                //            UserControlReal userControlReal = new UserControlReal();
                //            FlawsView.Children.Add(userControlReal);
                //            //Canvas.SetLeft(userControlReal, x);    //这里可能还要做数据的转换
                //            //Canvas.SetTop(userControlReal, y );    //比如米数和坐标系对应距离的转换
                //            Canvas.SetLeft(userControlReal, GetReallyX(image.StartX, true));
                //            Canvas.SetTop(userControlReal, GetReallyY(image.StartY, true));
                //        }
                //        else if (image.Choice == 1)
                //        {
                //            UserControlEmpty userControlEmpty = new UserControlEmpty();
                //            FlawsView.Children.Add(userControlEmpty);
                //            //Canvas.SetLeft(userControlEmpty, x-5);
                //            //Canvas.SetTop(userControlEmpty, y);
                //            Canvas.SetLeft(userControlEmpty, GetReallyX(image.StartX));
                //            Canvas.SetTop(userControlEmpty, GetReallyY(image.StartY));
                //        }
                //        else
                //        {
                //            return;         //数据类型存入错误
                //        }
                //    }
                //}
                //else
                //{
                //    return; //该区域不存在直接返回
                //}
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("setUpDisPlay:{0}", ex.Message));
            }
        }
        //获取单例实例
        LabelUtils label = LabelUtils.getInstance();
        /// <summary>
        /// 默认创建标签个数
        /// 1、如果存在初始值和终止值则默认赋值
        /// 2、如果存在瑕疵点，则默认加载瑕疵点
        /// </summary>
        /// <param name="number"></param>
        public void addLable(int number)
        {
            try
            {
                if (number == 0) //非空校验
                {
                    return;
                }
                //新添加的逻辑
                double reallyInterval = (double)(998 - 69) / (number - 1);  //实际标签之间的间隔百分比
                double reallyLeftInterval = (double)18 / 469;   //标签左边实际间隔百分比
                double width = (double)addLabel.ActualWidth;
                double height = (double)addLabel.ActualHeight;
                //标签实际起始横纵坐标
                double userControlX = (double)reallyLeftInterval * width;
                double userControlY = (double)69 / 1066 * height;
                //标签实际间隔
                double space = (double)(reallyInterval / 1066) * height;
                label.deleteLabels();   //清空前面的List
                addLabel.Children.Clear();  //添加之前先清除界面上所有的UserControl，所以这里并不需要对UserControl1对象保存
                FlawsView.Children.Clear();
                //循环开始前应该先加载cm标签
                //该标签的纵坐标
                double startSpace = (double)49 / 1066 * height;
                double bY = (double)20 / 1066 * height;

                label.getUserControl3().Height = startSpace;    //加载刻度值标签(cm或m)
                label.getUserControl3().Width = width;
                addLabel.Children.Add(label.getUserControl3());
                Canvas.SetLeft(label.getUserControl3(), userControlX);
                Canvas.SetTop(label.getUserControl3(), bY);

                for (var i = 1; i <= number; i++)
                {
                    UserControl1 userControl = new UserControl1();
                    userControl.Height = space; //子标签的高度等于等间距的高度
                    userControl.Width = width;  //子标签的宽度等于控件窗体的宽度
                    addLabel.Children.Add(userControl);    //动态的添加用户控件

                    label.addLabels(userControl);       //将新创建的标签集合添加到内存标签集合中

                    //设置用户控件在Canvas中的位置
                    Canvas.SetLeft(userControl, userControlX);
                    Canvas.SetTop(userControl, userControlY);

                    //添加完了所有的label之后再动态的添加最后一个全局缩放按钮
                    //if (i == number) //循环结束时(这里需要详细的计算其位置)
                    //{
                    //    double bx = (double)127 / 431 * width;
                    //    double by = (double)730 / 809 * height;
                    //    addLabel.Children.Add(label.getUserControl2());
                    //    //Canvas.SetLeft(label.getUserControl2(), bx);
                    //    //Canvas.SetTop(label.getUserControl2(), userControlY);

                    //    Canvas.SetLeft(label.getUserControl2(), bx);
                    //    Canvas.SetTop(label.getUserControl2(), by);
                    //}
                    userControlY += space;
                }
                LabelData labelD = label.getLabelData();
                int start = labelD.Start;
                int end = labelD.End;
                List<UserControl1> list = label.getListObject();
                int addNumber = (end - start) / (list.Count);

                if (label.isNull())  //不为空，则重新加载显示数据
                {
                    showBingData(start, end);
                }
                //动态加载图标数据
                if (label.isNullImageData())
                {
                    //获取内存中的数据集合
                    List<ImageData> images = label.GetImageDatas();
                    int begin = labelD.Start;
                    //遍历赋值
                    for (var j = 0; j < images.Count; j++)
                    {
                        ImageData data = images[j];

                        double x = data.StartX * width / 2.2;
                        double y = (data.StartY - begin) / (addNumber - 1) * space;

                        y = (data.StartY - begin) * (addNumber - 1) * space / (end - start) + 10;
                        //判断它是加载的哪种类型的图片
                        if (data.Choice == 0)
                        {
                            UserControlReal userControlReal = new UserControlReal();
                            FlawsView.Children.Add(userControlReal);
                            //Canvas.SetLeft(userControlReal, x);    //这里可能还要做数据的转换
                            //Canvas.SetTop(userControlReal, y);    //比如米数和坐标系对应距离的转换
                            Canvas.SetLeft(userControlReal, GetReallyX(data.StartX, true));
                            Canvas.SetTop(userControlReal, GetReallyY(data.StartY, true));
                        }
                        else if (data.Choice == 1)
                        {
                            UserControlEmpty userControlEmpty = new UserControlEmpty();
                            FlawsView.Children.Add(userControlEmpty);
                            //Canvas.SetLeft(userControlEmpty, x-5);
                            //Canvas.SetTop(userControlEmpty, y);
                            Canvas.SetLeft(userControlEmpty, GetReallyX(data.StartX));
                            Canvas.SetTop(userControlEmpty, GetReallyY(data.StartY));
                        }
                    }
                }
                //加载上次的设值显示
                if (label.isNullSetData())
                {
                    double a = label.getSetData().Start;
                    double b = label.getSetData().End;
                    setUpDisPlay(a, b);
                }
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("addLable:{0}", ex.Message));
            }
        }

        private double _minY = 0;
        private double _maxY = 50;
        private double _minX = 0;
        private double _maxX = 2.2;
        public void AddFlaw(MFlawInfo flaw)
        {
            try
            {
                //var flawInfo = Selected(flaw.Id);
                if (FlawsView.Children.Count == 15)
                {
                    FlawsView.Children.RemoveRange(0, 3);
                    //FlawsView
                }
                for (int i = 0; i < 3; i++)
                {
                    Image img = new Image();
                    img.Width = 320;
                    img.Height = 160;
                    img.Tag = "Camera_" + (i + 1);
                    img.MouseLeftButtonDown += Img_MouseLeftButtonDown;
                    img.Margin = new Thickness(0, 10, 0, 0);
                    img.Source = OS.Spin.Common.UserConvert.Mat2BitmapSource(flaw.Mats[i]);
                    FlawsView.Children.Add(img);
                    scroll.ScrollToEnd();
                }
                //scroll.ScrollToBottom();
                //if (flaw.CenterY > _maxY - 5)
                //{
                //    MakeChangeY(_maxY + 50);
                //}
                //var fv = new UCFlawArm(flaw)
                //{
                //    Width = 25,
                //    Height = 25
                //};
                //this.FlawsView.Children.Add(fv);
                //SetReallyLocation(fv);
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("AddFlaw:{0}", ex.Message));
            }
        }

        private void Img_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {
            //MFlawSnapView flaw = (MFlawSnapView)(sender as Image).Tag;
            if (e.ClickCount == 2)
            {
                var fv = FlawView.GetInstance((sender as Image).Source, (sender as Image).Tag.ToString());
                fv.WindowState = WindowState.Maximized;
                fv.Topmost = true;
                fv.Focus();
                fv.Show();
            }
        }

        private const int LableCount = 23;

        private void MakeChangeY(double y)
        {
            try
            {
                _maxY = y;

                var space = (_maxY - _minY) / (LableCount);

                var cText = space;

                foreach (var c in addLabel.Children)
                {
                    var text = c as UserControl1;

                    if (null == text)
                    {
                        continue;
                    }

                    text.textData.Text = cText.ToString("f1");
                    cText += space;
                }


                foreach (var f in FlawsView.Children)
                {
                    var flaw = f as UCFlawArm;

                    if (null == flaw)
                    {
                        continue;
                    }

                    SetReallyLocation(flaw);
                }
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("MakeChangeY:{0}", ex.Message));
            }
        }

        private UCFlawArm _selected = null;

        public void Zero()
        {
            FlawsView.Children.Clear();
            //MakeChangeY(50);
            _selected = null;
        }

        public MFlawSnapView Selected(string id)
        {
            try
            {
                if (null != _selected)
                {
                    _selected.IsSelected = false;
                }
                UCFlawArm flaw = null;
                foreach (var f in FlawsView.Children)
                {
                    flaw = f as UCFlawArm;

                    if (null == flaw)
                    {
                        continue;
                    }

                    if (id.Equals(flaw.FlawInfo.Id))
                    {
                        break;
                    }
                }

                _selected = flaw;

                if (null != _selected)
                {
                    _selected.IsSelected = true;
                    return flaw.FlawInfo;
                }
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("Selected:{0}", ex.Message));
            }
            return null;
        }


        private void SetReallyLocation(UCFlawArm flaw)
        {
            var left = GetReallyX(flaw.FlawInfo.CenterX) - flaw.Width / 2;
            var top = GetReallyY(flaw.FlawInfo.CenterY) - flaw.Height / 2;

            Canvas.SetTop(flaw, top);
            Canvas.SetLeft(flaw, left);
        }
        private double GetReallyX(double x)
        {
            return this.FlawsView.ActualWidth / (_maxX - _minX) * (x - _minX);
        }

        private double GetReallyY(double y)
        {
            return this.FlawsView.ActualHeight / (_maxY - _minY) * (y - _minY);
        }
        private double _endData = -1;

        /// <summary>
        /// 给标签动态绑定设值
        /// </summary>
        /// <param name="startData"></param>
        /// <param name="endData"></param>
        public void showBingData(int startData, int endData)
        {
            try
            {
                if (_endData.Equals(endData))
                {
                    return;
                }

                _endData = endData;
                //并且这里没调用一次就需要更新这个startData,endData
                //最好的方法是封装成一个类
                //直接覆盖更新，保证是最新数据
                LabelData labelData = label.getLabelData();
                labelData.Start = startData;    //保存起始值
                labelData.End = endData;    //保存终点值

                ////检测一下赋值过程是否成功
                ////MessageBox.Show(labelData.ToString());
                List<UserControl1> list = label.getListObject();
                int addNumber = (endData - startData) / (list.Count - 1);
                for (var i = 0; i < list.Count; i++)
                {
                    list[i].LableText.runtimes = startData;
                    //list[i].LableText.runtimes = endData;
                    //list[i].DataContext = startData;
                    startData += addNumber;
                    //endData -= addNumber;
                    if (startData > endData)
                    {
                        return;
                    }
                }

                setUpDisPlay(labelData.Start, labelData.End);
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("showBingData:{0}", ex.Message));
            }
        }

        /// <summary>
        /// 鼠标拖动位置改变图标和标签的位置
        /// 1、changX代表鼠标改变的水平位置
        /// 2、changY代表鼠标改变的水平位置(因为这里暂时只做数据的上下改变所以只需要纵向坐标即可)
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public void changeWithMouse(double changX, double changY)
        {
            try
            {
                //重新规划数据，哪些需要重新设计和布局的
                //1、清空画布上的所有显示元素包括(标签、图标)
                //addLabel.Children.Clear();
                FlawsView.Children.Clear();
                #region 注释
                ////2、重新计算当前标签的位置
                //double width = (double)addLabel.ActualWidth;
                //double height = (double)addLabel.ActualHeight - changY;
                //int number = label.getListObject().Count;
                //int userControlX = 0;   //子控件的横坐标
                //double userControlY = 0;   //子控件的纵坐标

                //double space = (double)height / number;
                //label.deleteLabels();   //清空前面的List
                //for (var i = 1; i <= number; i++)
                //{
                //    UserControl1 userControl = new UserControl1();
                //    userControl.Height = space; //子标签的高度等于等间距的高度
                //    userControl.Width = width;  //子标签的宽度等于控件窗体的宽度
                //    addLabel.Children.Add(userControl);    //动态的添加用户控件
                //    label.addLabels(userControl);

                //    //设置用户控件在Canvas中的位置
                //    Canvas.SetLeft(userControl, userControlX);
                //    Canvas.SetTop(userControl, userControlY);

                //    userControlY += space;
                //} 
                #endregion
                LabelData labelD = label.getLabelData();
                #region 注释
                //int start = labelD.Start;
                //int end = labelD.End;
                //List<UserControl1> list = label.getListObject();
                //int addNumber = (end - start) / (list.Count);

                ////动态加载标签刻度
                //if (label.isNull())
                //{
                //    for (var i = 0; i < list.Count; i++)
                //    {
                //        start += addNumber;
                //        list[i].LableText.runtimes = start;
                //        if (start > end)
                //        {
                //            return;
                //        }
                //    }
                //} 
                #endregion
                if (label.isNullImageData())
                {
                    //获取内存中的数据集合
                    List<ImageData> images = label.GetImageDatas();
                    int begin = labelD.Start;
                    //遍历赋值
                    for (var j = 0; j < images.Count; j++)
                    {
                        ImageData data = images[j];

                        //double x = data.StartX * width / 2.2;
                        //double y = (data.StartY - begin) / addNumber * space;
                        //判断它是加载的哪种类型的图片
                        if (data.Choice == 0)
                        {
                            UserControlReal userControlReal = new UserControlReal();
                            FlawsView.Children.Add(userControlReal);
                            //Canvas.SetLeft(userControlReal, x );    //这里可能还要做数据的转换
                            //Canvas.SetTop(userControlReal, y);    //比如米数和坐标系对应距离的转换
                            Canvas.SetLeft(userControlReal, GetReallyX(data.StartX, true));
                            Canvas.SetTop(userControlReal, GetReallyY(data.StartY, true));
                        }
                        else if (data.Choice == 1)
                        {
                            UserControlEmpty userControlEmpty = new UserControlEmpty();
                            FlawsView.Children.Add(userControlEmpty);
                            //Canvas.SetLeft(userControlEmpty, x -5);
                            //Canvas.SetTop(userControlEmpty, y);
                            Canvas.SetLeft(userControlEmpty, GetReallyX(data.StartX));
                            Canvas.SetTop(userControlEmpty, GetReallyY(data.StartY));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("changeWithMouse:{0}", ex.Message));
            }
        }

        /// <summary>
        /// 随窗体自适应改变重新加载赋值
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void AddLabel_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            if (null == sender || label.getListObject().Count == 0)
            {
                return;
            }

            //1、自适应重新加载Label          
            //2、自适应重新加载标签刻度
            //重新加载图片的坐标(只要坐标一改变就重新加载)
            //3、自适应重新加载图标
            //addLable(label.getListObject().Count);
        }

        SquareBoxUtils squareBoxUtils = SquareBoxUtils.getInstance();
        /// <summary>
        /// 点击瑕疵图片重新加载显示瑕疵点的状态(一次加载cm标签、瑕疵点、全局放大按钮)
        /// </summary>
        /// <param name="defectShowDatas"></param>
        public void reloadDefectShowData(List<DefectShowData> defectShowDatas)
        {
            try
            {
                DefectShowData defectShowData = null;
                List<OS.Spin.View.Utils.ControlUserOne> controlUserOnes = squareBoxUtils.getUserControlFathers();
                //这一步我只要找到是哪个瑕疵点照片被点击了
                for (var i = 0; i < controlUserOnes.Count; i++)
                {
                    int ground = controlUserOnes[i].ground;
                    int j = 0;
                    if (j == 1)  //已经找到了就直接退出
                    {
                        continue;
                    }

                    if (ground == 1)
                    {
                        j++;
                        OS.Spin.View.SquareBox.UserControOne userControOne = controlUserOnes[i].userControOne;
                        StackPanel stackPanel = userControOne.StackPanel;

                        //找到下面显示数据的用户控件
                        OS.Spin.View.SquareBox.UserControl1 userControl1 = (OS.Spin.View.SquareBox.UserControl1)stackPanel.Children[2];
                        //UserControl1的父StackPanel
                        StackPanel stackFather = userControl1.StackPanel;

                        StackPanel stackOne = (StackPanel)stackFather.Children[0];  //破洞
                        TextBlock textOne = (TextBlock)stackOne.Children[1];
                        String hole = textOne.Text;     //  取role值

                        StackPanel stackTwo = (StackPanel)stackFather.Children[1];  //尺寸
                        TextBlock textTwo = (TextBlock)stackTwo.Children[1];
                        String size = textTwo.Text;     //取size值

                        StackPanel stackThree = (StackPanel)stackFather.Children[2];    //属性
                        TextBlock textThree = (TextBlock)stackThree.Children[1];
                        String attribute = textThree.Text;
                        //能够比较的前提是瑕疵点照片没有重复的两张照片
                        defectShowData = new DefectShowData(hole, size, attribute);
                    }
                }
                //直接清空该画布
                //addLabel.Children.Clear();
                FlawsView.Children.Clear();
                //获取控件的实际高度和宽度
                int width = (int)addLabel.ActualWidth;  //该Canvas控件的实际宽度
                int height = (int)addLabel.ActualHeight;    //该Canvas控件的实际高度
                LabelData labelData = label.getLabelData();     //存放标签刻度的JavaBean
                int start = labelData.Start;    //刻度起始值
                int end = labelData.End;     //刻度终止值
                int number = label.getListObject().Count;


                //addLable(number);

                //int addNumber = (end - start) / (number - 1);    //标签的间隔数值
                //                                                 //double space = (double)height / number;    //每一间隔所对应的纵坐标值
                //                                                 //新添加的逻辑
                //double reallyInterval = (double)(998 - 69) / (number - 1);  //实际标签之间的间隔百分比
                //double reallyLeftInterval = (double)18 / 469;   //标签左边实际间隔百分比

                //double userControlX = (double)reallyLeftInterval * width;   //实际起始横坐标
                //double userControlY = (double)69 / 1066 * height;    //实际起始纵坐标
                //                                                     //标签实际间隔
                //double space = (double)(reallyInterval / 1066) * height;
                double pWidth = 0;
                double pHeight = 0;
                //double x = 0;
                //double y = 0;
                ////循环开始前应该先加载cm标签
                ////该标签的纵坐标
                //double startSpace = (double)49 / 1066 * height;
                //double bY = (double)20 / 1066 * height;

                //label.getUserControl3().Height = startSpace;    //加载刻度值标签(cm或m)
                //label.getUserControl3().Width = width;
                //addLabel.Children.Add(label.getUserControl3());
                //Canvas.SetLeft(label.getUserControl3(), userControlX);
                //Canvas.SetTop(label.getUserControl3(), bY);


                //if (label.isNull())  //不为空，则重新加载显示数据
                //{
                //    showBingData(start, end);
                //}

                for (var j = 0; j < defectShowDatas.Count; j++)
                {
                    //对比首先不为空，如果存在就改变，如果不存在则不改变(只有破洞，尺寸，属性都对上才证明是这个瑕疵点)
                    if (null != defectShowData && defectShowData.hole.Equals(defectShowDatas[j].hole) &&
                        defectShowData.size.Equals(defectShowDatas[j].size) &&
                        defectShowData.attribute.Equals(defectShowDatas[j].attribute))
                    {
                        pWidth = defectShowDatas[j].defectWidth;
                        pHeight = defectShowDatas[j].defectHeight;
                        if (pWidth > 2.2 || pHeight > end || pHeight < start)
                        {
                            continue;
                        }
                        //根据该瑕疵点的长度和宽度计算点的位置
                        //x = pWidth * width / 2.2 - 5;    //横坐标
                        //y = (pHeight - start) / addNumber * space ;   //纵坐标
                        UserControlEmpty userControlReal = new UserControlEmpty();
                        FlawsView.Children.Add(userControlReal);
                        //Canvas.SetLeft(userControlReal, x);    //这里可能还要做数据的转换
                        //Canvas.SetTop(userControlReal, y);    //比如米数和坐标系对应距离的转换
                        Canvas.SetLeft(userControlReal, GetReallyX(pWidth));
                        Canvas.SetTop(userControlReal, GetReallyY(pHeight));
                    }
                    else
                    {
                        //如果是1直接显示圆(表示选择态)
                        pWidth = defectShowDatas[j].defectWidth;
                        pHeight = defectShowDatas[j].defectHeight;
                        if (pWidth > 2.2 || pHeight > end || pHeight < start)
                        {
                            continue;
                        }
                        //根据该瑕疵点的长度和宽度计算点的位置
                        //x = pWidth * width / 2.2 ;    //横坐标
                        //y = (pHeight - start) / addNumber * space ;   //纵坐标
                        UserControlReal userControlReal = new UserControlReal();
                        FlawsView.Children.Add(userControlReal);
                        //Canvas.SetLeft(userControlReal, x );    //这里可能还要做数据的转换
                        //Canvas.SetTop(userControlReal, y);    //比如米数和坐标系对应距离的转换
                        Canvas.SetLeft(userControlReal, GetReallyX(pWidth, true));
                        Canvas.SetTop(userControlReal, GetReallyY(pHeight, true));
                    }
                    //if (j == defectShowDatas.Count) //循环结束时(这里需要详细的计算其位置)
                    //{
                    //    double bx = (double)127 / 431 * width;
                    //    double by = (double)730 / 809 * height;
                    //    addLabel.Children.Add(label.getUserControl2());
                    //    //Canvas.SetLeft(label.getUserControl2(), bx);
                    //    //Canvas.SetTop(label.getUserControl2(), userControlY);

                    //    Canvas.SetLeft(label.getUserControl2(), bx);
                    //    Canvas.SetTop(label.getUserControl2(), by);
                    //}
                }
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("reloadDefectShowData:{0}", ex.Message));
            }
        }

        /// <summary>
        /// 初始化根据瑕疵图片来加载瑕疵点
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void UserControl_Loaded(object sender, RoutedEventArgs e)
        {
            //List<DefectShowData> defectShowDatas = squareBoxUtils.getDefectShowDatas();     //获取瑕疵点数据

            ////注册瑕疵图片状态改变函数(注册委托)
            //DefectShowDelegateUtil defectShowDelegateUtil = squareBoxUtils.getDefectShowDelegateUtil();
            //defectShowDelegateUtil.defectShowDelegate += reloadDefectShowData;
            //if (defectShowDatas.Count == 0 || defectShowDatas == null)      //假如从内存中没有取到数据(说明还没有瑕疵点数据传过来)
            //{
            //    return;
            //}

            ////获取控件的实际高度和宽度
            //int width = (int)addLabel.ActualWidth;  //该Canvas控件的实际宽度
            //int height = (int)addLabel.ActualHeight;    //该Canvas控件的实际高度


            //LabelData labelData = label.getLabelData();     //存放标签刻度的JavaBean
            //int start = labelData.Start;    //刻度起始值
            //int end = labelData.End;     //刻度终止值
            //int number = label.getListObject().Count;   //获取标签个数


            ////计算瑕疵点的实际坐标
            //double reallyInterval = (double)(998 - 69) / (number - 1);  //实际标签之间的间隔百分比
            //double reallyLeftInterval = (double)18 / 469;   //标签左边实际间隔百分比

            //double userControlX = (double)reallyLeftInterval * width;   //实际起始横坐标
            //double userControlY = (double)69 / 1066 * height;    //实际起始纵坐标
            ////标签实际间隔
            //double space = (double)(reallyInterval / 1066) * height;

            //for (int i = 0; i < defectShowDatas.Count; i++)
            //{
            //    ////如果是1直接显示圆(表示选择态)
            //    double pWidth = defectShowDatas[i].defectWidth;
            //    double pHeight = defectShowDatas[i].defectHeight;
            //    if (pWidth > 2.2 || pHeight > end || pHeight < start)
            //    {
            //        continue;
            //    }
            //    //默认是未选中状态，即开始是小圆圈
            //    //double x = pWidth * width / 2.2;    //横坐标
            //    //double y = (pHeight - start) / addNumber * space;   //纵坐标
            //    UserControlReal userControlReal = new UserControlReal();
            //    FlawsView.Children.Add(userControlReal);
            //    //Canvas.SetLeft(userControlReal, x);    //这里可能还要做数据的转换
            //    //Canvas.SetTop(userControlReal, y);    //比如米数和坐标系对应距离的转换
            //    Canvas.SetLeft(userControlReal, GetReallyX(pWidth, true));
            //    Canvas.SetTop(userControlReal, GetReallyY(pHeight, true));
            //}
            try
            {
                ////新添加的逻辑
                //double reallyInterval = (double)(998 - 69) / (LableCount - 1);  //实际标签之间的间隔百分比
                //double reallyLeftInterval = (double)18 / 469;   //标签左边实际间隔百分比
                //double width = (double)addLabel.ActualWidth;
                //double height = (double)addLabel.ActualHeight;
                ////标签实际起始横纵坐标
                //double userControlX = (double)reallyLeftInterval * width;
                //double userControlY = (double)69 / 1066 * height;
                ////标签实际间隔
                //double space = (double)(reallyInterval / 1066) * height;

                ////循环开始前应该先加载cm标签
                ////该标签的纵坐标
                //double startSpace = (double)49 / 1066 * height;
                //double bY = (double)20 / 1066 * height;

                //var lableCm = new UserControl3();
                //lableCm.Height = startSpace;    //加载刻度值标签(cm或m)
                //lableCm.Width = width;
                //addLabel.Children.Add(lableCm);
                //Canvas.SetLeft(lableCm, userControlX);
                //Canvas.SetTop(lableCm, bY);

                //for (var i = 1; i <= LableCount; i++)
                //{
                //    UserControl1 userControl = new UserControl1();
                //    userControl.Height = space; //子标签的高度等于等间距的高度
                //    userControl.Width = width;  //子标签的宽度等于控件窗体的宽度
                //    addLabel.Children.Add(userControl);    //动态的添加用户控件

                //    label.addLabels(userControl);       //将新创建的标签集合添加到内存标签集合中

                //    //设置用户控件在Canvas中的位置
                //    Canvas.SetLeft(userControl, userControlX);
                //    Canvas.SetTop(userControl, userControlY);

                //    userControlY += space;
                //}

                //MakeChangeY(50);
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("UserControl_Loaded:{0}", ex.Message));
            }
        }

        /// <summary>
        /// 获取真实的Y轴坐标
        /// </summary>
        /// <param name="y"></param>
        /// <param name="isSelected"></param>
        /// <returns></returns>
        private double GetReallyY(double y, bool isSelected = false)
        {
            try
            {
                var r = label.getLabelData();

                var perY = this.FlawsView.ActualHeight / (r.End - r.Start);

                var center = 17;

                if (isSelected)
                {
                    center -= 5;
                }
                var data = perY * (y - r.Start) - center;
                return data;
            }
            catch (Exception ex)
            {
                LogisTrac.WriteLog(string.Format("GetReallyY:{0}", ex.Message));
                return 0;
            }
        }

        /// <summary>
        /// 获取真实的x轴坐标
        /// </summary>
        /// <param name="x"></param>
        /// <param name="isSelected"></param>
        /// <returns></returns>
        public double GetReallyX(double x, bool isSelected = false)
        {
            var perX = this.FlawsView.ActualWidth / 2.2;

            var head = 17;

            if (isSelected)
            {
                head -= 5;
            }

            return perX * x - head;
        }
        private Point _startPosition;
        //滚动条当前位置
        private double _startVerticalOffset;

        private void scroll_TouchDown(object sender, System.Windows.Input.TouchEventArgs e)
        {
            //获取ScrollViewer滚动条当前位置
            _startVerticalOffset = scroll.VerticalOffset;
            _startPosition = e.GetTouchPoint(this).Position;
            scroll.TouchMove -= Scroll_TouchMove;
            scroll.TouchMove += Scroll_TouchMove;
        }
        private void Scroll_TouchMove(object sender, System.Windows.Input.TouchEventArgs e)
        {
            //获取相对于ScrollViewer的触摸点位置
            TouchPoint endPoint = e.GetTouchPoint(this);
            //计算相对位置
            double diffOffsetY = endPoint.Position.Y - _startPosition.Y;

            //ScrollViewer滚动到指定位置(指定位置=起始位置-移动的偏移量，滚动方向和手势方向相反)
            scroll.ScrollToVerticalOffset(_startVerticalOffset - diffOffsetY);
        }

        private void scroll_TouchUp(object sender, TouchEventArgs e)
        {
            scroll.TouchMove -= Scroll_TouchMove;
        }
    }
}