Esempio n. 1
0
        /// <summary>
        /// Gets the intersection with another curve, which is calculated by iteration.
        /// <seealso cref="Cross(Curve , out double, out double)"/>
        /// </summary>
        /// <param name="Curve">The other curve</param>
        /// <param name="InLam">A start parameter for this curve which is "near" to the solution</param>
        /// <param name="InMue">A start parameter for the other curve which is "near" to the solution</param>
        /// <param name="NearLam">Solution parameter for this curve</param>
        /// <param name="NearMue">Solution parameter for the other curve</param>
        /// <returns>true if there is a crosspoint else false.</returns>
        public bool Cross(Curve Curve, double InLam, double InMue, out double NearLam, out double NearMue)
        {
            NearLam = InLam;
            NearMue = InMue;

            double _nearLam;
            double _nearMue;

            if (Double.IsNaN(Curve.Value(0).x))
            {
                return(false);
            }

            if (Double.IsNaN(Value(0).x))
            {
                return(false);
            }
            double     di1 = (float)1 / (float)Resolution;
            double     di2 = (float)1 / (float)Curve.Resolution;
            xy         Q1;
            xy         Q2;
            bool       weiter = false;
            xy         _A     = Value(NearLam - di1 / 2);
            xy         _B     = Value(NearLam + di1 / 2);
            xy         C      = Curve.Value(NearMue - di2 / 2);
            xy         D      = Curve.Value(NearMue + di2 / 2);
            LineType2d L1     = new LineType2d(_A, _B - _A);
            LineType2d L2     = new LineType2d(C, D - C);

            if (L1.Cross(L2, out _nearLam, out _nearMue))
            {
                NearLam = NearLam - di1 + _nearLam * di1;
                NearMue = NearMue - di2 + _nearLam * di2;
            }

            bool Left1 = false;
            bool Left2 = false;

            do
            {
                di1 = di1 / 2;
                di2 = di2 / 2;
                if ((NearLam / di1 - Utils.trunc(NearLam / di1)) > 0.5)
                {
                    Left1 = false;
                    _A    = Value(NearLam);
                    _B    = Value(NearLam + di1);
                }
                else
                {
                    Left1 = true;
                    _A    = Value(NearLam - di1);
                    _B    = Value(NearLam);
                }
                L1 = new LineType2d(_A, _B - _A);

                if (NearMue / di2 - Utils.trunc(NearMue / di2) > 0.5)
                {
                    Left2 = false;
                    C     = Curve.Value(NearMue);
                    D     = Curve.Value(NearMue + di2);
                }
                else
                {
                    Left2 = true;
                    C     = Curve.Value(NearMue - di2);
                    D     = Curve.Value(NearMue);
                }
                L2 = new LineType2d(C, D - C);

                weiter = false;
                if (L1.Cross(L2, out _nearLam, out _nearMue))
                {
                    if (Left1)
                    {
                        NearLam = NearLam - di1 + _nearLam * di1;
                    }
                    else
                    {
                        NearLam = NearLam + _nearLam * di1;
                    }

                    if (Left2)
                    {
                        NearMue = NearMue - di2 + _nearMue * di2;
                    }
                    else
                    {
                        NearMue = NearMue + _nearMue * di2;
                    }

                    weiter = true;
                }
                Q1 = Value(NearLam);
                Q2 = Curve.Value(NearMue);
            }while ((weiter) && (!Q1.Equals(Q2)));
            return(Q1.Equals(Q2) && (!Utils.Less(NearLam, 0)) && (!Utils.Less(1, NearLam)) &&
                   (System.Math.Abs(InMue - NearMue) < 0.2) && (System.Math.Abs(InLam - NearLam) < 0.2) && (!Utils.Less(NearMue, 0)) && (!Utils.Less(1, NearMue)));
        }