Exemple #1
0
        /// <summary>
        /// 获取对角线
        /// </summary>
        static Snap.NX.Line GetDiagonalLine(Snap.NX.Body body, out Snap.NX.Face baseFace)
        {
            Snap.NX.Line result   = null;
            var          workPart = Snap.Globals.WorkPart;
            var          box      = body.Box;
            var          p2       = new Snap.Position((box.MaxX + box.MinX) / 2, (box.MaxY + box.MinY) / 2);
            var          lines    = new List <NXOpen.NXObject>();

            if (!string.IsNullOrEmpty(body.Name))
            {
                lines = workPart.NXOpenPart.Layers.GetAllObjectsOnLayer(body.Layer).Where(l => l is NXOpen.Line).ToList();
                lines.ToList().ForEach(u =>
                {
                    Snap.NX.Line line = u as NXOpen.Line;
                    bool isRemove     = true;
                    if (Snap.Compute.Distance(line, body) < SnapEx.Helper.Tolerance)
                    {
                        var p1 = (line.StartPoint + line.EndPoint) / 2;
                        p2.Z   = p1.Z;
                        if (SnapEx.Helper.Equals(p1, p2, SnapEx.Helper.Tolerance))
                        {
                            isRemove = false;
                        }
                    }

                    if (isRemove)
                    {
                        lines.Remove(u);
                    }
                });
            }
            GetBaseFace(body, Enumerable.Select(lines, u => Snap.NX.Line.Wrap(u.Tag)).ToList(), out baseFace, out result);
            return(result);
        }
Exemple #2
0
        /// <summary>
        /// 获取对角线
        /// </summary>
        Snap.NX.Line GetDiagonalLine(Snap.NX.Body body)
        {
            Snap.NX.Line result   = null;
            var          workPart = Snap.Globals.WorkPart;

            var box = body.Box;

            var p2 = new Snap.Position((box.MaxX + box.MinX) / 2, (box.MaxY + box.MinY) / 2);

            if (!string.IsNullOrEmpty(body.Name))
            {
                var lines = workPart.NXOpenPart.Layers.GetAllObjectsOnLayer(body.Layer).Where(l => l is NXOpen.Line).ToList();
                lines.ForEach(u =>
                {
                    Snap.NX.Line line = u as NXOpen.Line;
                    var p1            = (line.StartPoint + line.EndPoint) / 2;
                    p2.Z = p1.Z;
                    if (SnapEx.Helper.Equals(p1, p2, JYElecHelper._tolerance))
                    {
                        result = line;
                        return;
                    }
                });
            }

            return(result);
        }
Exemple #3
0
 private Snap.NX.Line[] LineArray(Snap.NX.Curve[] curveArray)
 {
     Snap.NX.Line[] lineArray = new Snap.NX.Line[curveArray.Length];
     for (int i = 0; i < curveArray.Length; i++)
     {
         lineArray[i] = (NXOpen.Line)curveArray[i].NXOpenTaggedObject;
     }
     return(lineArray);
 }
Exemple #4
0
 public static Snap.NX.Line[] Copy(Transform xform, params Snap.NX.Line[] original)
 {
     Snap.NX.Line[] lineArray = new Snap.NX.Line[original.Length];
     for (int i = 0; i < original.Length; i++)
     {
         lineArray[i] = original[i].Copy(xform);
     }
     return(lineArray);
 }
Exemple #5
0
 public Snap.NX.Line[] IsoCurveU(double constantU)
 {
     Snap.NX.Curve[] nxObjects = Create.IsoparametricCurve(this, Create.DirectionUV.U, constantU, 0.0254);
     Snap.NX.Line[]  lineArray = new Snap.NX.Line[nxObjects.Length];
     for (int i = 0; i < nxObjects.Length; i++)
     {
         lineArray[i] = Create.Line(nxObjects[i].StartPoint, nxObjects[i].EndPoint);
     }
     Snap.NX.NXObject.Delete(nxObjects);
     return(lineArray);
 }
Exemple #6
0
        /// <summary>
        /// 获取基准面
        /// </summary>
        static void GetBaseFace(Snap.NX.Body body, List <Snap.NX.Line> diagonalLines, out Snap.NX.Face face, out Snap.NX.Line line)
        {
            Snap.NX.Face outFace = null;
            Snap.NX.Line outLine = null;
            var          faces   = body.Faces.ToList();

            faces = faces.Where(u => u.ObjectSubType == Snap.NX.ObjectTypes.SubType.FacePlane).ToList();
            var baseFace = faces.Where(u => u.IsHasAttr(ELEC_BASE_EDM_FACE)).FirstOrDefault();

            if (baseFace != null)
            {
                faces = new List <Snap.NX.Face> {
                    baseFace
                };
            }
            var tempFaces = faces.Where(u => SnapEx.Helper.Equals(u.GetFaceDirection(), -Snap.Globals.WcsOrientation.AxisZ, SnapEx.Helper.Tolerance)).ToList();

            tempFaces = tempFaces.OrderByDescending(u => {
                var uv = u.BoxUV;
                return(Math.Abs(uv.MinU - uv.MaxU) * Math.Abs(uv.MaxV - uv.MinV));
            }).ToList();

            tempFaces.ForEach(u =>
            {
                faces.Remove(u);
            });

            faces.InsertRange(0, tempFaces);

            foreach (var u in faces)
            {
                var corners = u.Box.Corners.Distinct().ToList();
                foreach (var item in diagonalLines)
                {
                    Snap.NX.Line diagonalLine = item;
                    if (Snap.Compute.Distance(diagonalLine, u) < SnapEx.Helper.Tolerance)
                    {
                        var startPos = corners.Where(m => SnapEx.Helper.Equals(m, diagonalLine.StartPoint, SnapEx.Helper.Tolerance));
                        var endPos   = corners.Where(m => SnapEx.Helper.Equals(m, diagonalLine.EndPoint, SnapEx.Helper.Tolerance));
                        if (startPos.Count() > 0 && endPos.Count() > 0)
                        {
                            outFace = u;
                            outLine = diagonalLine;
                            face    = outFace;
                            line    = outLine;
                            return;
                        }
                    }
                }
            }
            face = outFace;
            line = outLine;
        }
Exemple #7
0
        /// <summary>
        /// 获取对角线
        /// </summary>
        static Snap.NX.Line GetDiagonalLine(Snap.NX.Body body, out Snap.NX.Face baseFace)
        {
            Snap.NX.Line result = null;
            baseFace = null;
            var workPart = Snap.Globals.WorkPart;
            var box      = body.Box;
            var p2       = new Snap.Position((box.MaxX + box.MinX) / 2, (box.MaxY + box.MinY) / 2, (box.MaxZ + box.MinZ) / 2);
            var lines    = new List <Snap.NX.Line>();

            if (!string.IsNullOrEmpty(body.Name))
            {
                lines = workPart.NXOpenPart.Layers.GetAllObjectsOnLayer(body.Layer).ToArray().Where(u => u is NXOpen.Line).Select(u => Snap.NX.Line.Wrap(u.Tag)).ToList();
                foreach (var line in lines.ToList())
                {
                    if (!Entry.Instance.IsDistinguishSideElec)
                    {
                        var p1      = (line.StartPoint + line.EndPoint) / 2;
                        var tempVec = p1 - p2;
                        var tempOri = Snap.Globals.Wcs.Orientation.AxisZ;
                        if ((
                                SnapEx.Helper.Equals(tempVec, tempOri, SnapEx.Helper.Tolerance) ||
                                SnapEx.Helper.Equals(tempVec, -tempOri, SnapEx.Helper.Tolerance) ||
                                SnapEx.Helper.Equals(p1, p2, SnapEx.Helper.Tolerance)
                                ) && Snap.Compute.Distance(line, body) < SnapEx.Helper.Tolerance
                            )
                        {
                        }
                        else
                        {
                            lines.Remove(line);
                        }
                    }
                    else
                    {
                        if (Snap.Compute.Distance(line, body) < SnapEx.Helper.Tolerance)
                        {
                        }
                        else
                        {
                            lines.Remove(line);
                        }
                    }
                }
            }
            if (lines.Count > 0)
            {
                GetBaseFace(body, lines, out baseFace, out result);
            }
            return(result);
        }
Exemple #8
0
        void FrmTool_Load(object sender, EventArgs e)
        {
            var theSession = NXOpen.Session.GetSession();
            var workPart   = theSession.Parts.Work;

            if (workPart == null)
            {
                MessageBox.Show("未打开部件!");
                Close();
                return;
            }

            var list = new List <JYElecInfo>();

            Snap.Globals.WorkPart.Bodies.ToList().ForEach(u =>
            {
                if (JYElecHelper.IsElec(u) && !string.IsNullOrEmpty(u.Name))
                {
                    var lines      = new List <Snap.NX.Line>();
                    var allObjects = workPart.Layers.GetAllObjectsOnLayer(u.Layer).Where(l => l is NXOpen.Line).ToList();
                    var box        = u.Box;
                    var p2         = new Snap.Position((box.MaxX + u.Box.MinX) / 2, (box.MaxY + box.MinY) / 2, 0);
                    allObjects.ForEach(a =>
                    {
                        Snap.NX.Line l = a as NXOpen.Line;
                        var p1         = (l.StartPoint + l.EndPoint) / 2;
                        p2.Z           = p1.Z;
                        if (SnapEx.Helper.Equals(p1, p2, JYElecHelper._tolerance))
                        {
                            lines.Add(l);
                            return;
                        }
                    });

                    var basePoint = new Snap.Position();
                    if (lines.Count > 0)
                    {
                        var line  = lines.First();
                        basePoint = (line.StartPoint + line.EndPoint) / 2;
                    }

                    var mainElec = list.FirstOrDefault(m => m.ElecName == u.Name);
                    if (mainElec == null)
                    {
                        mainElec                    = new JYElecInfo();
                        mainElec.ElecName           = u.Name;
                        mainElec.ELEC_FINISH_NUMBER = (int)JYElecHelper.GetAttrValue(u, JYElecConst.ELEC_FINISH_NUMBER);
                        mainElec.ELEC_MIDDLE_NUMBER = (int)JYElecHelper.GetAttrValue(u, JYElecConst.ELEC_MIDDLE_NUMBER);
                        mainElec.ELEC_ROUGH_NUMBER  = (int)JYElecHelper.GetAttrValue(u, JYElecConst.ELEC_ROUGH_NUMBER);
                        mainElec.ELEC_FINISH_SPACE  = (double)JYElecHelper.GetAttrValue(u, JYElecConst.ELEC_FINISH_SPACE);
                        mainElec.ELEC_MIDDLE_SPACE  = (double)JYElecHelper.GetAttrValue(u, JYElecConst.ELEC_MIDDLE_SPACE);
                        mainElec.ELEC_ROUGH_SPACE   = (double)JYElecHelper.GetAttrValue(u, JYElecConst.ELEC_ROUGH_SPACE);
                        list.Add(mainElec);
                    }

                    if (lines.Count > 0)
                    {
                        var pInfo = mainElec.PositioningInfos.FirstOrDefault();
                        var info  = new JYPositioningInfo();
                        info.X    = basePoint.X;
                        info.Y    = basePoint.Y;
                        info.Z    = basePoint.Z;
                        info.NXObjects.Add(u);
                        info.NXObjects.Add(lines.FirstOrDefault().NXOpenLine);

                        var infoStartPoint = lines.First().StartPoint;
                        var infoEndPoint   = lines.First().EndPoint;
                        info.Lines.Add(infoStartPoint);
                        info.Lines.Add(infoEndPoint);
                        info.FaceDir = JYElecHelper.GetBaseFace(lines.First().StartPoint, lines.First().EndPoint, u).GetFaceDirection();
                        if (pInfo != null)
                        {
                            var startPoint = pInfo.Lines.First();
                            var endPoint   = pInfo.Lines.Last();

                            info.Rotation = Snap.Vector.Angle(endPoint - startPoint, infoStartPoint - infoEndPoint);
                        }
                        mainElec.PositioningInfos.Add(info);
                    }
                }
            });

            gridControl1.DataSource = list;
            ;
        }
Exemple #9
0
        /// <summary>
        /// 获取基准面
        /// </summary>
        static void GetBaseFace(Snap.NX.Body body, List <Snap.NX.Line> diagonalLines, out Snap.NX.Face face, out Snap.NX.Line line)
        {
            Snap.NX.Face outFace = null;
            Snap.NX.Line outLine = null;
            var          faces   = body.Faces.ToList();

            faces = faces.Where(u => u.ObjectSubType == Snap.NX.ObjectTypes.SubType.FacePlane).ToList();
            var baseFace = faces.Where(u => u.IsHasAttr(ELEC_BASE_EDM_FACE)).FirstOrDefault();

            if (baseFace != null)
            {
                faces = new List <Snap.NX.Face> {
                    baseFace
                };
            }

            var tempFaces = new List <Snap.NX.Face>();

            if (!Entry.Instance.IsDistinguishSideElec)
            {
                tempFaces = faces.Where(u => SnapEx.Helper.Equals(u.GetFaceDirection(), -Snap.Globals.WcsOrientation.AxisZ, SnapEx.Helper.Tolerance)).ToList();
            }
            else
            {
                tempFaces.AddRange(faces.Where(u =>
                                               SnapEx.Helper.Equals(u.GetFaceDirection(), -Snap.Globals.WcsOrientation.AxisZ, SnapEx.Helper.Tolerance) ||
                                               SnapEx.Helper.Equals(u.GetFaceDirection(), Snap.Globals.WcsOrientation.AxisZ, SnapEx.Helper.Tolerance) ||
                                               SnapEx.Helper.Equals(u.GetFaceDirection(), -Snap.Globals.WcsOrientation.AxisX, SnapEx.Helper.Tolerance) ||
                                               SnapEx.Helper.Equals(u.GetFaceDirection(), Snap.Globals.WcsOrientation.AxisX, SnapEx.Helper.Tolerance) ||
                                               SnapEx.Helper.Equals(u.GetFaceDirection(), -Snap.Globals.WcsOrientation.AxisY, SnapEx.Helper.Tolerance) ||
                                               SnapEx.Helper.Equals(u.GetFaceDirection(), Snap.Globals.WcsOrientation.AxisY, SnapEx.Helper.Tolerance)
                                               ).ToList());
            }

            tempFaces = tempFaces.OrderByDescending(u =>
            {
                var uv = u.BoxUV;
                return(Math.Abs(uv.MinU - uv.MaxU) * Math.Abs(uv.MaxV - uv.MinV));
            }).ToList();

            tempFaces.ForEach(u =>
            {
                faces.Remove(u);
            });

            faces = tempFaces;

            foreach (var item in diagonalLines.ToList())
            {
                Snap.NX.Line diagonalLine = item;
                if (Snap.Compute.Distance(diagonalLine, body) >= SnapEx.Helper.Tolerance)
                {
                    diagonalLines.Remove(item);
                }
            }

            foreach (var u in faces)
            {
                var tempDiagonaLines = new List <Snap.NX.Line>();
                foreach (var item in diagonalLines)
                {
                    Snap.NX.Line diagonalLine = item;
                    if (Snap.Compute.Distance(diagonalLine, u) < SnapEx.Helper.Tolerance)
                    {
                        tempDiagonaLines.Add(item);
                    }
                }

                if (tempDiagonaLines.Count > 0)
                {
                    var uBoxUV      = u.BoxUV;
                    var centerPoint = u.Position((uBoxUV.MaxU + uBoxUV.MinU) / 2, (uBoxUV.MaxV + uBoxUV.MinV) / 2);
                    foreach (var item in tempDiagonaLines)
                    {
                        Snap.NX.Line diagonalLine = item;
                        if (SnapEx.Helper.Equals(centerPoint, (diagonalLine.StartPoint + diagonalLine.EndPoint) / 2, SnapEx.Helper.Tolerance))
                        {
                            outFace = u;
                            outLine = diagonalLine;
                            face    = outFace;
                            line    = outLine;
                            return;
                        }
                    }
                }
            }
            face = outFace;
            line = outLine;
        }
Exemple #10
0
        public void GetElecInfo(JYElecInfo mainElec)
        {
            var workPart = Snap.Globals.WorkPart;
            var bodys    = workPart.Bodies.Where(u => u.Name == mainElec.ElecName).ToList();
            var body     = bodys.FirstOrDefault();
            var box3d    = body.Box;

            mainElec.ELEC_FINISH_NUMBER = GetDoubleAttr(body, JYElecConst.ELEC_FINISH_NUMBER);
            mainElec.ELEC_MIDDLE_NUMBER = GetDoubleAttr(body, JYElecConst.ELEC_MIDDLE_NUMBER);
            mainElec.ELEC_ROUGH_NUMBER  = GetDoubleAttr(body, JYElecConst.ELEC_ROUGH_NUMBER);
            mainElec.ELEC_FINISH_SPACE  = GetDoubleAttr(body, JYElecConst.ELEC_FINISH_SPACE);
            mainElec.ELEC_MIDDLE_SPACE  = GetDoubleAttr(body, JYElecConst.ELEC_MIDDLE_SPACE);
            mainElec.ELEC_ROUGH_SPACE   = GetDoubleAttr(body, JYElecConst.ELEC_ROUGH_SPACE);
            mainElec.ELEC_MAT_NAME      = GetAttrValue(body, JYElecConst.ELEC_MAT_NAME);
            mainElec.CLAMP_GENERAL_TYPE = GetAttrValue(body, JYElecConst.CLAMP_GENERAL_TYPE);
            mainElec.ELEC_MACH_TYPE     = GetAttrValue(body, JYElecConst.ELEC_MACH_TYPE);
            mainElec.F_ELEC_SMOOTH      = GetAttrValue(body, JYElecConst.F_ELEC_SMOOTH);
            mainElec.M_ELEC_SMOOTH      = GetAttrValue(body, JYElecConst.M_ELEC_SMOOTH);
            mainElec.R_ELEC_SMOOTH      = GetAttrValue(body, JYElecConst.R_ELEC_SMOOTH);
            mainElec.SPECL = Math.Abs(box3d.MaxX - box3d.MinX);
            mainElec.SPECW = Math.Abs(box3d.MaxY - box3d.MinY);
            mainElec.SPECH = Math.Abs(box3d.MaxZ - box3d.MinZ);

            mainElec.PositioningInfos.Clear();
            bodys.ForEach(u => {
                Snap.NX.Line line = GetDiagonalLine(u);
                if (line != null)
                {
                    var basePoint = (line.StartPoint + line.EndPoint) / 2;
                    var info      = new JYPositioningInfo();
                    info.X        = basePoint.X;
                    info.Y        = basePoint.Y;
                    info.Z        = basePoint.Z;
                    info.NXObjects.Add(u);
                    info.NXObjects.Add(line.NXOpenLine);

                    var cornerface = JYElecHelper.GetBaseCornerFace(line.StartPoint, line.EndPoint, u);
                    if (cornerface != null)
                    {
                        var type = SnapEx.Helper.GetQuadrantType(cornerface.GetFaceDirection());
                        info.C   = "右上角";
                        if (type == QuadrantType.Second)
                        {
                            info.C = "左上角";
                        }
                        else if (type == QuadrantType.Three)
                        {
                            info.C = "左下角";
                        }
                        else if (type == QuadrantType.Four)
                        {
                            info.C = "右下角";
                        }
                    }

                    var infoStartPoint = line.StartPoint;
                    var infoEndPoint   = line.EndPoint;
                    info.Lines.Add(infoStartPoint);
                    info.Lines.Add(infoEndPoint);
                    //info.FaceDir = JYElecHelper.GetBaseFace(line.StartPoint, line.EndPoint, u).GetFaceDirection();

                    mainElec.PositioningInfos.Add(info);
                }
            });
        }