/// 增加引线C000条件0828
        /// 增加无屑加工条件0829
        /// 增加模拟用程序面0829
        /// 增加普通斜度度数独一行0929
        /// 增加普通斜度退刀0929
               /// 上下异形退刀0929

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Reflection;
using System.Text;
using XYCAM.Entites;


namespace XYCAM.Script
{
    public class XycamScriptClass : ScriptBase
    {

        #region 自定义方法


        /// <summary>
        /// 自定义的放电参数库
        /// </summary>
        private Dictionary<int, string[]> 内孔放电参数字典 = new Dictionary<int, string[]>
                {
                    //数字表示对应高度,花括号内表示 1~9 刀 对应的条件代码
                    { 5, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 10, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 15, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 20, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 30, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 40, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 50, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 60, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 70, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 80, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 90, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 100, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 120, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 150, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 200, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                };

        /// <summary>
        /// 自定义的放电参数库
        /// </summary>
        private Dictionary<int, string[]> 外形放电参数字典 = new Dictionary<int, string[]>
                {
                    //数字表示对应高度,花括号内表示 1~9 刀 对应的条件代码
                    { 5, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 10, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 15, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 20, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 30, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 40, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 50, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 60, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 70, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 80, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 90, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 100, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 120, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 150, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                    { 200, new string[] { "C001", "C002", "C003", "C904", "C905", "C906", "C907", "C908", "C909",  } },
                };


        /// <summary>
        /// 获取当前刀次的放电参数
        /// </summary>
        private string E2
        {
            get
            {
                Dictionary<int, string[]> dict = V1 == 0 ? 内孔放电参数字典 : 外形放电参数字典;
                var keys = dict.Keys.ToList();
                //搜寻对应高度的参数数组下标
                var keyIndex = keys.BinarySearch((int)V22);
                if (keyIndex < 0) keyIndex = ~keyIndex;

                //获取参数数组
                var values = dict[keys[keyIndex]];
                if (V12 > (V32 + 1))//切断单独补正时
                {
                    return values[0];
                }
                else
                {
                    //返回对应刀次的参数
                    return values[V12 - 1];
                }
            }
        }





        //总线长的变量
        private double totalLength = 0;

        /// <summary>
        /// 判断是否为开粗工序,且不为切断
        /// </summary>
        private bool 是否为开粗工序
        {
            get
            {
                return V12 == 1 && V36 != 1;
            }
        }

        /// <summary>
        /// 判断上下异形2个面的起点是否在同一位置
        /// </summary>
        private bool 上下异形垂直进刀
        {
            get
            {

                return Math.Abs(XS.Value - XS2.Value) < 1E-3
                      && Math.Abs(YS.Value - YS2.Value) < 1E-3;

                //判断程序面起点X和Y坐标是否和辅助面起点X和Y坐标一致
                // return XS.Value == XS2.Value && YS.Value == YS2.Value;
            }
        }

        /// <summary>
        /// 是否关闭加工电源
        /// </summary>
        private bool 是否关闭加工电源;


        /// <summary>
        /// 每刀对应的标题集合
        /// </summary>
        private string[] titles = new string[] { "1ST", "2ND", "3RD", "4TH", "5TH", "6TH", "7TH", "8TH", "9TH", "10TH", };

        /// <summary>
        /// 当前刀次对应的标题
        /// </summary>
        private string currentTitle
        {
            get
            {
                if (V36 == 1)
                {
                    return "CutOff";//切断
                }
                else if (V36 == 3)
                {
                    return "NoCoreInner";//无屑内芯
                }
                else
                {
                    return titles[V12 - 1];
                }
            }
        }

        /// <summary>
        /// 运行2d轨迹
        /// </summary>
        /// <returns></returns>
        private void Run2()
        {

            //锥度输出,与上一个锥度不同时
            if (T != LastT)
            {
                Add(G41orG42 ? G52 : G51);
                Add(T2);
            }
            //添加默认的坐标
            Add(Cut, X, Y);


            //为圆弧时
            if ((int)CuttingMode > 1)
            {
                //添加圆弧坐标
                Add(I, J);
                //获取半径或直径的字符,这里用三元表达式,同统赢的一样
                string r = IsCircle ? Fmt("D", R * 2) : R;
                //添加半径或者直径标识字符
                Add("( ", r, " )");

            }
            //刀口模式,修刀不输出
            if (V87 == 9 && !(V57 == 1 && V12 > 1))
            {
                //同R时加入同R的机器字符
                Add(Fmt("R", R3));
            }


            //换行
            AddL();
        }


        /// <summary>
        /// 运行3d轨迹
        /// </summary>
        /// <returns></returns>
        private void Run3()
        {
            if (Cut == G1 || Cut == G0)
            {
                //两平面格式
                Add(Cut, X, Y);
            }
            else
            {
                //两平面格式
                Add(Cut, X, Y, I, J);
            }

            //辅助面的加工逻辑
            //如果是会员版,可以将以下 的Cut改成Cut2
            //这样的话支持同一段路径,一个走直线一个走圆弧
            if (Cut == G1 || Cut == G0)
            {
                //两平面格式
                Add(":" + Cut, X2, Y2);
            }
            else
            {
                //两平面格式
                Add(":", Cut, X2, Y2, I2, J2);
            }

            // if (Cut2 == G1 || Cut2 == G0)
            // {
            //     //两平面格式
            //     Add(":" + Cut2, X2, Y2);
            // }
            // else
            // {
            //     //两平面格式
            //     Add(":", Cut2, X2, Y2, I2, J2);
            // }
            AddL();
        }

        /// <summary>
        /// 记录上一个标签
        /// </summary>
        string preTitle = "";

        /// <summary>
        /// 程序面字典, 查询键为字符(程序面+辅助面) ,对应的值为 整数类型(子程序面呼叫号码)
        /// </summary>
        Dictionary<string, int> progamPlaneDictionary = new Dictionary<string, int>();

        /// <summary>
        /// 子程序面集合字符,最后加入到程序结尾操作区域
        /// </summary>
        string progamPlanes = "";




        #endregion


        /// <summary>
        /// 初始化参数
        /// </summary>
        protected override void Init()
        {
            V4 = 0;
            D.Set(3, "H");
            D1.Set(3, "H");
            Dv.Set(3);
            E.Set(3, "C");
            E1.Set(3, "C");
            N.Set(4, "N");
            F.Set(3, "F");
            T.Set(4, "A");
            T1.Set(4, "A");
            X.Set(4, "X");
            Y.Set(4, "Y");
            U.Set(4, "U");
            V.Set(4, "V");
            W.Set(3, "W");
            I.Set(4, "I");
            J.Set(4, "J");


            XS.Set(4, "X");
            YS.Set(4, "Y");
            US.Set(4, "U");
            VS.Set(4, "V");
            XS1.Set(4, "X");
            YS1.Set(4, "Y");
            XS2.Set(4, "X");
            YS2.Set(4, "Y");


            X2.Set(4, "X");//两平面时的辅助面X
            Y2.Set(4, "Y");//两平面时的辅助面Y
            I2.Set(4, "I");//两平面时的辅助面I
            J2.Set(4, "J");//两平面时的辅助面J

            R.Set(3, "R");
            K.Set(4, "K");
            L.Set(4, "L");
            Z1.Set(3, "Z");
            Z2.Set(3, "I");
            StartX.Set(4, "X");
            StartY.Set(4, "Y");
            //补正分组关闭(1:开启)
            V11 = 0;


            MachineType = "沙迪克";
            V55 = 1;//上下同R走沙迪克模式
            V33 = 1;//每行代码后面加上;

            // V61 = ".NC";
            // V62 = 0.001;//上下异形圆弧分段(如果设置数值,则按照数值表示的进度分段)
        }



        /// <summary>
        /// 补偿列
        /// </summary>
        /// <param name="i">补偿组编号</param>
        /// <returns></returns>
        protected override string OffsetRow(int i)
        {
            //如果不想输出,可改为 return "";
            string str = ((char)('A' + i)).ToString();
            return "(" + str + ")" + QN;
        }

        /// <summary>
        /// 补正项
        /// </summary>
        /// <param name="d">补偿编号</param>
        /// <param name="dv">补偿值</param>
        /// <returns></returns>
        protected override string OffsetItem(int d, double dv)
        {
            // 格式化补偿值
            string fmtVal = dv.ToString("+000000.0000");
            return Fmt("H", d, 3) + "=" + fmtVal;
        }


        /// <summary>
        /// 程序开始
        /// </summary>
        /// <returns></returns>
        public override void ProgamStart()
        {
            AddL("(" + Date + ")");
            AddL("H996=+000000.0020  (PUNCH-1 外形开粗)");
            AddL("H997=+000000.0020  (PUNCH-1 外形修刀)");
            AddL("H998=+000000.0050  (PUNCH-1 内孔开粗)");
            AddL("H999=+000000.0020  (PUNCH-1 内孔修刀)");
            AddL("H000=+000000.0000");
            AddL(OffsetGroup());//添加补正组
            AddL("");

{
   // if (V2 == 0&& V31==0 && V29 == 0&&!HasAngle)  {AddL("(主程序面="+V25.ToString("0.000")+"副程序面="+V31.ToString("0.000")+"工件顶面="+V25.ToString("0.000")+"工件底部=0.0 TP"+V25.ToString("0.000")+" TN"+V31.ToString("0.000")+ ")"); }
    if (V2 == 0&& V31==0 && V29 == 0&& HasAngle)    {AddL("(主程序面="+V29.ToString("0.000")+"副程序面="+V25.ToString("0.000")+"工件顶面="+V25.ToString("0.000")+"工件底部=0.0 TP"+V29.ToString("0.000")+" TN"+V25.ToString("0.000")+ ")"); }
    if (V2== 0&&V29!=0&&V31!=0)                     {AddL("(主程序面="+V29.ToString("0.000")+"副程序面="+V31.ToString("0.000")+"工件顶面="+V25.ToString("0.000")+"工件底部=0.0 TP"+V29.ToString("0.000")+" TN"+V31.ToString("0.000")+ ")"); }
    if (V2== 0&&V29==0&&V31!=0)                     {AddL("(主程序面="+V29.ToString("0.000")+"副程序面="+V31.ToString("0.000")+"工件顶面="+V25.ToString("0.000")+"工件底部=0.0 TP"+V29.ToString("0.000")+" TN"+V31.ToString("0.000")+ ")"); }
    if (V2== 0&&V29!=0&&V31==0)                     {AddL("(主程序面="+V29.ToString("0.000")+"副程序面="+V31.ToString("0.000")+"工件顶面="+V25.ToString("0.000")+"工件底部=0.0 TP"+V29.ToString("0.000")+" TN"+V31.ToString("0.000")+ ")"); }
    if (V2== 1&&V31==0&&V29==0)                     {AddL("(主程序面="+V29.ToString("0.000")+"副程序面="+V25.ToString("0.000")+"工件顶面="+V25.ToString("0.000")+"工件底部=0.0 TP"+V29.ToString("0.000")+" TN"+V25.ToString("0.000")+ ")"); }
    if (V2== 1&&V29!=0&&V31!=0)                     {AddL("(主程序面="+V29.ToString("0.000")+"副程序面="+V31.ToString("0.000")+"工件顶面="+V25.ToString("0.000")+"工件底部=0.0 TP"+V29.ToString("0.000")+" TN"+V31.ToString("0.000")+ ")"); }
    if (V2== 1&&V28==0&&V29==0&&V31!=0)             {AddL("(主程序面="+V29.ToString("0.000")+"副程序面="+V31.ToString("0.000")+"工件顶面="+V25.ToString("0.000")+"工件底部=0.0 TP"+V29.ToString("0.000")+" TN"+V31.ToString("0.000")+ ")"); }
    if (V2== 1&&V28!=0&&V29==0&&V31!=0)             {AddL("(主程序面="+V29.ToString("0.000")+"副程序面="+V31.ToString("0.000")+"工件顶面="+V25.ToString("0.000")+"工件底部=0.0 TP"+V29.ToString("0.000")+" TN"+V31.ToString("0.000")+ ")"); }

}
            AddL("");
            AddL("TP20.00");
            AddL("TN0.00");
            AddL("G90");
            AddL("G54");
            AddL("G11 (改成G12开启排短路功能)");
        }


        /// <summary>
        /// 程序结束
        /// </summary>
        /// <returns></returns>
        public override void ProgamEnd()
        {
            //添加程序面集合
            AddL(progamPlanes);
            //AddL("(::  Total Length Of Cutting Feed = ", Fmt("", totalLength, 3), ")");
            AddL("T83 C777\r\nM00\r\nM00\r\nM02\r\nN9999  (  SHORT )\r\nG91\r\nWT0 WS33\r\nG01X0.001\r\nG04X4.0\r\nWT22 WS33\r\nG01X-0.001\r\nG04X4.0\r\nWT160 WS70\r\nG90\r\nM99\r\n(WIRE=SODICK)");
        }


        /// <summary>
        /// 孔开始
        /// </summary>
        /// <returns></returns>
        protected override void Start()
        {
            //叠加线长,记录总线长
            totalLength += V41;
            if (N == 1)
            {
                if (Is3d)
                {
                    AddL("HOLD(请检查程式面后在加工!!!)");
                }
            }

            // 根据Is3d判断添加不同的后缀
            if (Is3d)
            {
                AddL(N + "( --- SODICK.3D --- )");
            }
            else
            {
                AddL(N + "( --- SODICK.2D --- )");
            }

            AddL(Cut, X, Y);//跳步XY坐标
        }

        /// <summary>
        /// 添加程式面
        /// </summary>
        private void AddProamPlane()
        {
            //将当前孔的程序面+辅助面组合成字符,用做key查询字典
            string key = V29 + "," + V31;

            int index;
            //查询字典中有没有存在对应的元素,如果没有
            if (!progamPlaneDictionary.ContainsKey(key))
            {
                //记录字典中元素的数量
                int count = progamPlaneDictionary.Count;
                //设置子程序号
                index = count + 8001;
                //存入 程序面+辅助面组合 作为键   , 子程序号码 作为值
                progamPlaneDictionary.Add(key, index);

                //这个progamPlanes是一个自定义变量,在上面的用户自定义变量中,
                //用变量承载子程序的字符,最后加入到程序结尾操作区域
                progamPlanes += "(<--- Plane " + (count + 1) + " --->)" + QN;
                progamPlanes += "N" + index + QN;
                progamPlanes += "G92 " + Fmt("J", V29) + " " + Fmt("I", V31) + QN;
                progamPlanes += "M99" + QN + QN;
            }
            //如果有对应的元素,则获取对应的子程序号码
            else
            {
                index = progamPlaneDictionary[key];
            }
            //在当前程序执行处加入呼叫子程序的代码
            AddL("M98P", index);
        }

        /// <summary>
        /// 补正偏移
        /// </summary>
        /// <returns></returns>
        protected override void Offset()
        {

        }


        /// <summary>
        /// 进刀点
        /// </summary>
        /// <returns></returns>
        protected override void Feed()
        {
            //如果加工电源被关闭,那么打开它
            if (是否关闭加工电源)
            {
                是否关闭加工电源 = false;
            }

            //切断第一刀,且修线头打开时
            if (V47 && V36 == 1 && V12 == 1)
            {
                AddL("");
                AddL("M00");
            }

            AddL("CRT(------ " + N + "-" + currentTitle + " ------)");


            if (V36 == 3)//无屑内芯
            {
                AddL("T84C000" );
                AddL("/M98P9999");
            }

             if (V12 == 1 && !V39 &&V36!=1)//不为无屑外圈时
            {
                AddL("T84C000" );
                AddL("/M98P9999");
            }
             if (V12 == 1 && V36==1)//不为无屑外圈时
            {
                AddL("T84C000" );

            }
             if (V12 > 1 )//不为无屑外圈时
            {
                AddL("T85" + E2 + "(" + D + ")");

            }

   if (!HasAngle&&V36 == 3){Add(G41orG42 ? G40 + "H000" + G52 : G40 + "H000" + G51, "A0.");AddL(Cut + X + Y); }
   if (HasAngle&&V36 == 3){Add(G41orG42 ? G40 + "H000" + G52 : G40 + "H000" + G51, T2);AddL(Cut + X + Y); }
   if (V36 != 3){Add(G41orG42 ? G42 + "H000" + G52 : G41 + "H000" + G51, "A0."); AddL(Cut + X + Y);}  
            if (V36 != 3)//无屑内芯不用切换
            {
                string zhuibu = "";
                if (!HasAngle)
                {
                    if (V1 == 0)
                    {
                        zhuibu = (V12 == 1) ? "AH998" : "AH999";
                    }
                    else
                    {
                        zhuibu = (V12 == 1) ? "AH996" : "AH997";
                    }
                }


    if (HasAngle&&V36!=2&&V36!=3&&V57==1)
    {
if (V12==1) {AddL(G41orG42 ? G52 : G51, T2);}
    }

   if (HasAngle&&V36!=2&&V36!=3&&V57!=1){AddL(G41orG42 ? G52 : G51, T2);}
   if (HasAngle&&V36==2) {AddL(G41orG42 ? G51 : G52, "A",V28.ToString("0.000"));  }

            if (V12 == 1 )//不为无屑外圈时
            {
                AddL("T84" + E2 + "(" + D + ")");

            }






                // 拼接输出 避免多;符号
                if (string.IsNullOrEmpty(zhuibu))
                {
                    AddL(D);
                }
                else
                {
                    AddL(string.Format("{0} {1}", D, zhuibu));
                }
            }
        }

        /// <summary>
        /// 暂停点
        /// </summary>
        /// <returns></returns>
        protected override void M01()
        {
            Run2();
            if (!V47)
            {
                AddL("M00C000");
            }
        }

        /// <summary>
        /// 闭合点
        /// </summary>
        /// <returns></returns>
        protected override void Close()
        {
            Run2();
        }

        /// <summary>
        /// 过切点
        /// </summary>
        /// <returns></returns>
        protected override void OverCut()
        {
            Run2();
        }

        /// <summary>
        /// 脱离点
        /// </summary>
        /// <returns></returns>
        protected override void Out()
        {
            Add("G40H000G50A0.0");
            if (V1 == 0)//内孔
            {
                if (HasAngle )//内孔并且包含角度时
                {
                    AddL("M05G00", XS1, YS1);
                }
                else   if (!HasAngle && V5 != 2)//内孔并且包含角度时
                
                {
                    AddL("M05G00", XS1, YS1);
                }
                else
                {
                    AddL("M05G00", X, Y);
                }
            }
            else//外形,开形
            {
                AddL(Cut, X, Y);
            }

            //判断是否为外形第一刀
            if (是否为开粗工序 && V1 == 1)
            {
                //加入暂停3秒
                AddL("G04X3.");
            }
        }

        /// <summary>
        /// 常规加工
        /// </summary>
        /// <returns></returns>
        protected override void Default()
        {
            Run2();
        }

        /// <summary>
        /// 同一个孔中的跳步(如内孔旋转进刀,外形多线头)
        /// </summary>
        /// <returns></returns>
        protected override void Move()
        {
            //内孔
            if (V1 == 0)
            {
                if (V35)
                {
                    AddL(G0, X, Y);
                }
            }
            //开放路径
            else if (V1 == 2)
            {
                //开形转外形也需要读这里
                AddL(G0, X, Y);
            }
            else if (V8 < 3000) //否则剪线再跳步,并穿线
            {
                AddL("T90");
                AddL(G0, X, Y);
                AddL("T91");
            }
        }

        /// <summary>
        /// 上下异形进刀
        /// </summary>
        /// <returns></returns>
        protected override void Feed3d()
        {
            //如果加工电源被关闭,那么打开它
            if (是否关闭加工电源)
            {
                是否关闭加工电源 = false;
            }

            //切断第一刀,且修线头打开时
            if (V47 && V36 == 1 && V12 == 1)
            {
                AddL("T90");
                AddL("T91");
            }

            AddL("CRT(------ " + N + "-" + currentTitle + " ------)");


            if (V36 == 3)//无屑内芯
            {
                AddL("T84", E2);
                AddL("/M98P9999");
                AddL("G149G249G349G449G549G649G749");
            }
            else if (V12 == 1 && !V39)//不为无屑外圈时
            {
                AddL("T84", E2);
                AddL("/M98P9999");
            }
            else
            {
                AddL("T85", E2);
            }

            Add(G41orG42 ? "G142H000" : "G141H000");

            Run3();

            if (V36 != 3)//无屑内芯不用切换
            {
                //开粗时进刀线后加入正常补正码
                AddL(D);
            }
        }

        /// <summary>
        /// 补正
        /// </summary>
        /// <returns></returns>
        protected override void Offset3d()
        {

        }

        /// <summary>
        /// 常规路径
        /// </summary>
        /// <returns></returns>
        protected override void Default3d()
        {
            Run3();
        }

        /// <summary>
        /// 上下异形脱离
        /// </summary>
        /// <returns></returns>
        protected override void Out3d()
        {

    if (上下异形垂直进刀 == false )                              {AddL("H000");Run3();}   ////斜进斜出两平面
    if (V1==2&&上下异形垂直进刀 == true)                         {AddL("H000"); AddL(G1, X+0.001 , Y, ":", G1, X+0.001 , Y);AddL("G140", G1, X, Y);}//外形//脱离距离
    if (V1 ==1&&上下异形垂直进刀 == true&&V36!=1)                {AddL("H000");Run3(); AddL(G1, X+0.001 , Y, ":", G1, X+0.001 , Y);AddL("G140", G1, X, Y);}//外形//脱离距离
    if (V1 ==1&&上下异形垂直进刀 == true&&V36==1)                {AddL("H000");AddL(G1, X+0.001 , Y, ":", G1, X+0.001 , Y);AddL("G140", G1, X, Y);}//外形//切断脱离距离
    if (V1== 0&&上下异形垂直进刀 == true&&V5!=2&&!V35)           {AddL("H000");Run3();AddL(G0, XS+0.001 , YS, ":", G0, XS+0.001 , YS);AddL("M05G140", G0, XS, YS);}//脱离到起割点//内孔不旋转边割边修  非自动化
    if (V1== 0&&上下异形垂直进刀 == true&&V5!=2&&V35)            {AddL("H000");Run3();AddL(G0, XS1+0.001 , YS1, ":", G0, XS1+0.001 , YS1);AddL("M05G140", G0, XS1, YS1);}//脱离//内孔旋转边割边修，非自动化
    if (V1== 0&&上下异形垂直进刀 == true&&V5==2&&N<1000&&V12==1) {AddL("H000");Run3(); AddL("T90");AddL(G0, XS+0.001 , YS, ":", G0, XS+0.001 , YS);AddL("M05G140", G0, XS, YS); }//自动化加工粗割.内孔
    if (V1== 0&&上下异形垂直进刀 == true&&V5==2&&N>1000&&V12==1) {AddL("BACK0.4M00");AddL("H000"); Run3();AddL(G0, XS+0.001 , YS, ":", G0, XS+0.001 , YS);AddL("M05G140", G0, XS, YS);AddL("T90");}//自动化加工粗割切断.内孔
    if (V1== 0&&上下异形垂直进刀 == true&&V5==2&&V12>1&&V35)     {AddL("H000");Run3(); AddL(G0, XS1+0.001 , YS1, ":", G0, XS1+0.001 , YS1);AddL("M05G140", G0, XS1, YS1);    }//自动化加工修刀.旋转内孔
    if (V1== 0&&上下异形垂直进刀 == true&&V5==2&&V12>1&&!V35)    {AddL("H000");Run3();AddL(G0, XS+0.001 , YS, ":", G0, XS+0.001 , YS);AddL("M05G140", G0, XS, YS);}//自动化加工修刀.不旋转内孔
    if (V1 == 1&&V12==1 ){AddL("G4X10.");}

        }

        /// <summary>
        /// 上下异形前置暂停点
        /// </summary>
        protected override void M013d()
        {
            Run3();
            if (!V47)
                AddL("M01");
        }

        /// <summary>
        /// 上下异形过切点
        /// </summary>
        protected override void OverCut3d()
        {
            Run3();
        }

        /// <summary>
        /// 上下异形闭合点
        /// </summary>
        protected override void Close3d()
        {
            Run3();
        }

        /// <summary>
        /// 工序1开始
        /// </summary>
        public override void StartProcess1()
        {

        }

        /// <summary>
        /// 工序2开始
        /// </summary>
        public override void StartProcess2()
        {

        }

        /// <summary>
        /// 工序3开始
        /// </summary>
        public override void StartProcess3()
        {

        }

        /// <summary>
        /// 工序4开始
        /// </summary>
        public override void StartProcess4()
        {

        }


        /// <summary>
        /// 穿线
        /// </summary>
        protected override void WireOn()
        {
            AddL("T91");
            if (N == 1)
            {
                AddL("HOLD(请核对坐标再继续)");
            }
        }

        /// <summary>
        /// 剪线
        /// </summary>
        protected override void WireOff()
        {
            AddL("T90");
        }

        /// <summary>
        /// 进刀分段
        /// </summary>
        protected override void SegmentFeed()
        {
            Run2();
        }

        /// <summary>
        /// 上下异形进刀分段
        /// </summary>
        protected override void SegmentFeed3d()
        {
            Run3();
        }

        /// <summary>
        /// 返回线的进刀点
        /// </summary>
        protected override void BackLineFeed()
        {
            //关闭电源,更新标记
            是否关闭加工电源 = true;
            //输出关闭电源代码
            Add(G41orG42 ? G42 : G41);
            Run2();
        }

        /// <summary>
        /// 返回线的结束点
        /// </summary>
        protected override void BackLineEnd()
        {
            Default();
            //正常参数
            AddL(E);
        }

        /// <summary>
        /// 返回线的结束前的过渡区域
        /// </summary>
        protected override void TransitionZoneBeforeBackLineEnd()
        {
            Default();
            //如果加工电源被关闭,那么打开它
            if (是否关闭加工电源)
            {
                是否关闭加工电源 = false;
            }
            //输出过度的弱条件
            AddL("C000");
        }

        /// <summary>
        /// 局部无屑和水平自动化引线的共用起点
        /// </summary>
        protected override void NoOffsetFeed()
        {
            AddL("C000");
            //无补正加工
            Add("G40");
            Run2();
        }

        /// <summary>
        /// 在剪线之前的动作(其实也就是孔结束的时候)
        /// </summary>
        protected override void BeforeWireOff()
        {
            //记录上一个标签
            preTitle = Title;
        }
    }
}

//key,123456