static public double Skalarprodukt(
     Vektor2DDouble vektor0,
     Vektor2DDouble vektor1)
 {
     return
         (vektor0.A * vektor1.A + vektor0.B * vektor1.B);
 }
 static public double Kroizprodukt(
     Vektor2DDouble vektor0,
     Vektor2DDouble vektor1)
 {
     return
         (vektor0.A * vektor1.B - vektor0.B * vektor1.A);
 }
Exemple #3
0
 static public Vektor2DDouble NääxterPunktAufGeraade(
     Vektor2DDouble GeradeRichtung,
     Vektor2DDouble Punkt,
     Vektor2DDouble GeradeVersatz)
 {
     return(NääxterPunktAufGeraade(GeradeRichtung, Punkt - GeradeVersatz) + GeradeVersatz);
 }
Exemple #4
0
        static public bool ScnaidendGeraadeSegmentMitGeraadeSegment(
            Vektor2DDouble GeraadeSegment0Begin,
            Vektor2DDouble GeraadeSegment0Ende,
            Vektor2DDouble GeraadeSegment1Begin,
            Vektor2DDouble GeraadeSegment1Ende)
        {
            bool Paralel;
            bool Kolinear;
            bool Überlapend;

            if (ScnitpunktGeraadeSegmentMitGeraadeSegment(
                    GeraadeSegment0Begin,
                    GeraadeSegment0Ende,
                    GeraadeSegment1Begin,
                    GeraadeSegment1Ende,
                    out Paralel,
                    out Kolinear,
                    out Überlapend).HasValue)
            {
                return(true);
            }

            if (Überlapend)
            {
                return(true);
            }

            return(false);
        }
Exemple #5
0
        static public double DistanzVonPunktZuGeraadeSegment(
            Vektor2DDouble GeraadeSegmentBegin,
            Vektor2DDouble GeraadeSegmentEnde,
            Vektor2DDouble Punkt)
        {
            var AufGeraadeSegmentNääxterPunkt =
                Bib3.Geometrik.NääxterPunktAufGeraadeSegment(GeraadeSegmentBegin, GeraadeSegmentEnde, Punkt);

            return((Punkt - AufGeraadeSegmentNääxterPunkt).Betraag);
        }
Exemple #6
0
        static public Vektor2DDouble NääxterPunktAufGeraade(
            Vektor2DDouble GeradeRichtung,
            Vektor2DDouble Punkt)
        {
            GeradeRichtung.Normalisiire();

            var PositionAufGerade = Punkt.A * GeradeRichtung.A + Punkt.B * GeradeRichtung.B;

            return(new Vektor2DDouble(GeradeRichtung.A * PositionAufGerade, GeradeRichtung.B * PositionAufGerade));
        }
Exemple #7
0
        static public double Rotatioon(
            Vektor2DDouble Vektor0,
            Vektor2DDouble Vektor1)
        {
            var Richtung0 = Vektor0.Normalisiirt();
            var Richtung1 = Vektor1.Normalisiirt();

            var Punktprodukt = Math.Min(1, Math.Max(-1, Vektor2DDouble.Skalarprodukt(Richtung0, Richtung1)));

            var Rotatioon = Math.Acos(Punktprodukt) / Math.PI / 2;

            return(Rotatioon);
        }
Exemple #8
0
        /// <summary>
        /// Winkel(0) => (a=1,b=0)
        /// Winkel(1/4) => (a=0,b=1)
        /// Winkel(2/4) => (a=-1,b=0)
        /// Winkel(3/4) => (a=0,b=-1)
        /// </summary>
        /// <param name="Vektor"></param>
        static public double Rotatioon(Vektor2DDouble Vektor)
        {
            Vektor.Normalisiire();

            var Winkel = Math.Acos(Vektor.A) / Math.PI / 2;

            if (Vektor.B < 0)
            {
                Winkel = 1 - Winkel;
            }

            return(Winkel);
        }
Exemple #9
0
        static public Vektor2DDouble NääxterPunktAufGeraadeSegment(
            Vektor2DDouble GeraadeSegmentBegin,
            Vektor2DDouble GeraadeSegmentEnde,
            Vektor2DDouble SuuceUrscprungPunktLaage)
        {
            double AufGeraadeNääxtePunktLaage;

            return(NääxterPunktAufGeraadeSegment(
                       GeraadeSegmentBegin,
                       GeraadeSegmentEnde,
                       SuuceUrscprungPunktLaage,
                       out AufGeraadeNääxtePunktLaage));
        }
Exemple #10
0
        static public Vektor2DDouble NääxterPunktAufGeraadeSegment(
            Vektor2DDouble GeraadeSegmentBegin,
            Vektor2DDouble GeraadeSegmentEnde,
            Vektor2DDouble SuuceUrscprungPunktLaage,
            out double AufGeraadeNääxtePunktLaage)
        {
            var GeraadeSegmentLängeQuadraat = (GeraadeSegmentEnde - GeraadeSegmentBegin).BetraagQuadriirt;

            if (GeraadeSegmentLängeQuadraat <= 0)
            {
                if (SuuceUrscprungPunktLaage == GeraadeSegmentBegin)
                {
                    AufGeraadeNääxtePunktLaage = 0;
                }
                else
                {
                    AufGeraadeNääxtePunktLaage = double.PositiveInfinity;
                }

                return(GeraadeSegmentBegin);
            }

            AufGeraadeNääxtePunktLaage =
                Vektor2DDouble.Skalarprodukt(
                    SuuceUrscprungPunktLaage - GeraadeSegmentBegin,
                    GeraadeSegmentEnde - GeraadeSegmentBegin) /
                GeraadeSegmentLängeQuadraat;

            if (AufGeraadeNääxtePunktLaage < 0)
            {
                return(GeraadeSegmentBegin);
            }

            if (1 < AufGeraadeNääxtePunktLaage)
            {
                return(GeraadeSegmentEnde);
            }

            return
                (GeraadeSegmentBegin +
                 AufGeraadeNääxtePunktLaage * (GeraadeSegmentEnde - GeraadeSegmentBegin));
        }
Exemple #11
0
        /// <summary>
        /// http://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
        /// </summary>
        /// <param name="GeraadeSegment0Begin"></param>
        /// <param name="GeraadeSegment0Ende"></param>
        /// <param name="GeraadeSegment1Begin"></param>
        /// <param name="GeraadeSegment1Ende"></param>
        /// <param name="Paralel"></param>
        /// <returns></returns>
        static public Vektor2DDouble?ScnitpunktGeraadeSegmentMitGeraadeSegment(
            Vektor2DDouble GeraadeSegment0Begin,
            Vektor2DDouble GeraadeSegment0Ende,
            Vektor2DDouble GeraadeSegment1Begin,
            Vektor2DDouble GeraadeSegment1Ende,
            out bool Paralel,
            out bool Kolinear,
            out bool Überlapend)
        {
            Kolinear   = false;
            Überlapend = false;

            //	Suppose the two line segments run from p to p + r and from q to q + s
            var Segment0Vektor = GeraadeSegment0Ende - GeraadeSegment0Begin;
            var Segment1Vektor = GeraadeSegment1Ende - GeraadeSegment1Begin;

            var VektorKroizprodukt =
                Vektor2DDouble.Kroizprodukt(Segment0Vektor, Segment1Vektor);

            //	 Then any point on the first line is representable as p + t r (for a scalar parameter t)
            //	and any point on the second line as q + u s (for a scalar parameter u).

            //	t = (q − p) × s / (r × s)
            var ScnitpunktAufSegment0Antail =
                Vektor2DDouble.Kroizprodukt((GeraadeSegment1Begin - GeraadeSegment0Begin), Segment1Vektor) /
                VektorKroizprodukt;

            //	u = (q − p) × r / (r × s)
            var ScnitpunktAufSegment1Antail =
                Vektor2DDouble.Kroizprodukt((GeraadeSegment1Begin - GeraadeSegment0Begin), Segment0Vektor) /
                VektorKroizprodukt;

            if (0 == VektorKroizprodukt)
            {
                Paralel = true;

                if (0 == Vektor2DDouble.Kroizprodukt((GeraadeSegment1Begin - GeraadeSegment0Begin), Segment0Vektor))
                {
                    //	1.If r × s = 0 and (q − p) × r = 0, then the two lines are collinear.
                    Kolinear = true;

                    var Temp0 = Vektor2DDouble.Skalarprodukt(GeraadeSegment1Begin - GeraadeSegment0Begin, Segment0Vektor);
                    var Temp1 = Vektor2DDouble.Skalarprodukt(GeraadeSegment0Begin - GeraadeSegment1Begin, Segment1Vektor);

                    if (
                        0 <= Temp0 && Temp0 <= Vektor2DDouble.Skalarprodukt(Segment0Vektor, Segment0Vektor) ||
                        0 <= Temp1 && Temp1 <= Vektor2DDouble.Skalarprodukt(Segment1Vektor, Segment1Vektor))
                    {
                        //	If in addition, either 0 ≤ (q − p) · r ≤ r · r or 0 ≤ (p − q) · s ≤ s · s, then the two lines are overlapping.

                        Überlapend = true;
                        return(null);
                    }
                }
            }
            else
            {
                Paralel = false;

                //	4.If r × s ≠ 0 and 0 ≤ t ≤ 1 and 0 ≤ u ≤ 1, the two line segments meet at the point p + t r = q + u s.
                if (0 <= ScnitpunktAufSegment0Antail && ScnitpunktAufSegment0Antail <= 1 &&
                    0 <= ScnitpunktAufSegment1Antail && ScnitpunktAufSegment1Antail <= 1)
                {
                    return(GeraadeSegment0Begin + ScnitpunktAufSegment0Antail * Segment0Vektor);
                }
            }

            return(null);
        }
Exemple #12
0
 /// <summary>
 /// Links &lt; 0;
 /// Rechts &gt; 0;
 /// </summary>
 /// <param name="GeraadeRictung"></param>
 /// <param name="Punkt"></param>
 /// <returns></returns>
 static public int SaiteVonGeraadeZuPunkt(
     Vektor2DDouble GeraadeRictung,
     Vektor2DDouble Punkt)
 {
     return(Math.Sign(Vektor2DDouble.Skalarprodukt(Punkt, new Vektor2DDouble(-GeraadeRictung.B, GeraadeRictung.A))));
 }
Exemple #13
0
 static public double DistanzVonPunktZuGeraade(
     Vektor2DDouble GeradeRichtung,
     Vektor2DDouble Punkt)
 {
     return((NääxterPunktAufGeraade(GeradeRichtung, Punkt) - Punkt).Betraag);
 }