Beispiel #1
0
        /// <summary>
        ///     TODO
        /// </summary>
        /// <param name="loop"></param>
        /// <returns></returns>
        public static bool IsLargestLoop(this BoundaryLoop loop)
        {
            var length = loop.GetLength();

            if (length == 0)
            {
                return(false);
            }

            try
            {
                foreach (var fLoop in loop.Face.Loops)
                {
                    if (fLoop.IsEqualTo(loop))
                    {
                        continue;
                    }

                    var fLength = fLoop.GetLength();

                    if (fLength > length)
                    {
                        return(false);
                    }
                }

                return(true);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                MailAgent.Report(e.Message);
                return(false);
            }
        }
Beispiel #2
0
        /// <summary>
        ///     Todo
        /// </summary>
        /// <param name="loop"></param>
        /// <returns></returns>
        public static Enums.LoopKit GetLoopType(this BoundaryLoop loop)
        {
            if (!loop.IsLargestLoop())
            {
                return(Enums.LoopKit.Interior);
            }

            if (!SettingsUser.PrioritizeRightAngles)
            {
                return(Enums.LoopKit.Exterior);
            }

            try
            {
                foreach (var vtx in loop.Vertices)
                {
                    if (vtx.IsRightAngle3D())
                    {
                        return(Enums.LoopKit.RightAngle);
                    }
                }
            }
            catch
            {
                return(Enums.LoopKit.Error);
            }

            return(Enums.LoopKit.Undetermined);
        }
Beispiel #3
0
        /// <summary>
        ///     TODO
        /// </summary>
        /// <param name="vtx"></param>
        /// <param name="owner"></param>
        /// <returns></returns>
        private List <EdgeExt> GetEdges(Vertex vtx, BoundaryLoop owner)
        {
            var eList = new List <EdgeExt>();

            try
            {
                foreach (var edge in vtx.Edges)
                {
                    var eInfo = new EdgeExt(edge, vtx, owner);

                    if (eInfo.IsNull)
                    {
                        continue;
                    }

                    eList.Add(eInfo);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                MailAgent.Report(e.Message);
            }

            return(eList);
        }
Beispiel #4
0
        /// <summary>
        ///     TODO
        /// </summary>
        /// <param name="edge"></param>
        /// <param name="vtx"></param>
        /// <param name="owner"></param>
        public EdgeExt(Edge edge, Vertex vtx, BoundaryLoop owner)
        {
            OnLoop = edge.IsOnLoop(owner);

            try
            {
                using (var curve = edge.Curve)
                {
                    if (!(curve is ExternalCurve3d))
                    {
                        return;
                    }

                    using (var extCurve = curve as ExternalCurve3d)
                    {
                        using (var natCurve = extCurve.NativeCurve)
                        {
                            IsClosed = natCurve.IsClosed();

                            if (IsClosed)
                            {
                                using (var inv = natCurve.GetInterval())
                                {
                                    Eaxis = new Axis(natCurve.StartPoint,
                                                     natCurve.EvaluatePoint(inv.LowerBound + inv.UpperBound) / 2);
                                }
                            }
                            else
                            {
                                if (natCurve.StartPoint.IsEqualTo(vtx.Point))
                                {
                                    Eaxis = new Axis(natCurve.EndPoint, natCurve.StartPoint);
                                }
                                else
                                {
                                    Eaxis = new Axis(natCurve.StartPoint, natCurve.EndPoint);
                                }
                            }

                            IsLinear = natCurve is LinearEntity3d;

                            if (IsLinear)
                            {
                                Normal = natCurve.GetNormal();
                            }

                            Tangent = GetTangent(natCurve, Eaxis);

                            Length = Eaxis.Length;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                MailAgent.Report(e.Message);
            }
        }
        private static bool IsAtLeastTriangle(BoundaryLoop loop)
        {
            var edgeSum = 0;

            foreach (Edge edg in loop.Edges)
            {
                edgeSum++;
            }
            return(edgeSum > 2);
        }
Beispiel #6
0
        /// <summary>
        ///     Todo
        /// </summary>
        /// <param name="edge"></param>
        /// <param name="loop"></param>
        /// <returns></returns>
        public static bool IsOnLoop(this Edge edge, BoundaryLoop loop)
        {
            try
            {
                foreach (var lEdge in loop.Edges)
                {
                    if (lEdge.IsEqualTo(edge))
                    {
                        return(true);
                    }
                }
            }
            catch
            {
                return(false);
            }

            return(false);
        }
Beispiel #7
0
        /// <summary>
        ///     Todo
        /// </summary>
        /// <param name="loop"></param>
        /// <returns></returns>
        public static double GetLength(this BoundaryLoop loop)
        {
            try
            {
                double length = 0;

                foreach (var edge in loop.Edges)
                {
                    length += edge.GetLength();
                }

                return(length);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                MailAgent.Report(e.Message);
                return(0);
            }
        }
Beispiel #8
0
 /// <summary>
 ///     Todo
 /// </summary>
 /// <param name="comp1"></param>
 /// <param name="comp2"></param>
 /// <returns></returns>
 public static bool IsEqualTo(this BoundaryLoop comp1, BoundaryLoop comp2)
 {
     return(comp1 == comp2);
 }
Beispiel #9
0
        //TODO
        public VertExt(Vertex vtx, BoundaryLoop owner)
        {
            VertPoint   = vtx.Point;
            XEdge       = new EdgeExt();
            YEdge       = new EdgeExt();
            ZEdge       = new EdgeExt();
            Normal      = new Vector3d();
            _vertAngle  = 0.0;
            _rightAngle = false;
            _rightCs    = false;

            foreach (var eInfo in GetEdges(vtx, owner))
            {
                var sTang = eInfo.Tangent;

                if (sTang.Length < SettingsUser.TolPoint)
                {
                    continue;
                }

                if (eInfo.OnLoop)
                {
                    if (XEdge.IsNull)
                    {
                        XEdge = eInfo;
                    }
                    else if (XEdge.Length >= eInfo.Length)
                    {
                        YEdge = eInfo;
                    }
                    else
                    {
                        YEdge = XEdge;
                        XEdge = eInfo;
                    }

                    if (!Normal.IsLessThanTol())
                    {
                        continue;
                    }

                    Normal = eInfo.Normal;
                }
                else
                {
                    ZEdge = eInfo;
                }
            }

            if (XEdge.Length < SettingsUser.TolPoint)
            {
                return;
            }

            if (YEdge.Length > SettingsUser.TolPoint)
            {
                _vertAngle = XEdge.Tangent.GetAngleTo(YEdge.Tangent);
                if (_vertAngle <= SettingsInternal.TolVector * 10 ||
                    _vertAngle >= 3.14159265358979 - SettingsInternal.TolVector * 10)
                {
                    YEdge = new EdgeExt();
                }
                else
                {
                    if (SettingsUser.PrioritizeRightAngles)
                    {
                        _rightAngle = Math.Abs(_vertAngle - 1.5707963267949) < SettingsInternal.TolVector;
                    }

                    if (Normal.IsLessThanTol())
                    {
                        Normal = XEdge.Tangent.CrossProduct(YEdge.Tangent);
                    }
                }
            }

            if (ZEdge.Length < SettingsUser.TolPoint)
            {
                return;
            }

            if (!Normal.IsLessThanTol())
            {
                if (Normal.GetAngleTo(ZEdge.Tangent) > 1.5707963267949)
                {
                    Normal = Normal.Negate();
                }

                if (YEdge.Length > SettingsUser.TolPoint)
                {
                    _rightCs = YEdge.Tangent.GetAngleTo(Normal.CrossProduct(XEdge.Tangent)) <
                               1.5707963267949;
                }
            }
        }