Punkt auf Geraden bestimmen



  • Ich möchte FUnktion schreiben, die einen gewissen Punkt auf einer Geraden findet der auf der X achse liegt. es ist ziemlich schwer zu erklären.
    Der Punkt soll also folgende Kritierien erfüllen:er muss auf der vorgegebenen X oder Y Koordinate liegen, und er muss auf der Linie liegen.
    Also die Funktion soll einen Vektor mit der Richtung der Geraden und die Position auf der X oder Y Achse (float) entgegennehem.
    Ich hoffe das war verständlich.
    Weiss jemand wie das geht?



  • alterbro schrieb:

    Ich möchte FUnktion schreiben, die einen gewissen Punkt auf einer Geraden findet der auf der X achse liegt. es ist ziemlich schwer zu erklären.
    Der Punkt soll also folgende Kritierien erfüllen:er muss auf der vorgegebenen X oder Y Koordinate liegen, und er muss auf der Linie liegen.
    Also die Funktion soll einen Vektor mit der Richtung der Geraden und die Position auf der X oder Y Achse (float) entgegennehem.
    Ich hoffe das war verständlich.
    Weiss jemand wie das geht?

    Bitte ein Zahlenbeispiel. Was genau ist gegeben und was soll berechnet werden?



  • ok also wenn man eine 45° Grad ist dann sind x und y Koordinate des Punktes identsch. wenn die gerade senkrecht ist (0,1) dann ist der Punkt nicht berechenbar, wenn die vorgegebene X koordinte nicht genau 0 ist.
    Wenn der Punkt horizontal ist (1,0) dann ist bei jeder X, Koordinate Y=0.
    Ich hoffe das hilft weiter.


  • Mod

    alterbro schrieb:

    Ich hoffe das hilft weiter.

    Nein. Bitte sauber und der Reihenfolge nach in klarem Deutsch oder in klaren mathematischen Formeln. Fang an mit dem, was vorgegeben wird. Dann erklärst du, was gesucht wird. Dann gibst du ein oder zwei Zahlenbeispiele. Ein typischer Fall wäre gut und ein oder zwei Sonderfälle, an denen man die Schwierigkeit erkennt.

    Dann liest du den Beitrag nochmal, bevor du ihn abschickst und korrigierst sämtliche Rechtschreib- und Grammatikfehler, als ob dein Deutschlehrer hinter dir stünde. Dies wiederholst du dreimal.



  • Ok, also das Problem ist folgendes:
    Ich habe eine Gerade und den Y-Wert einer Koordinate.
    Ich möchte eine Funktion schreiben, die einen Punkt findet, der folgende Kriterien erfüllt:
    Die Der Y-Wert der Koordinate entspricht der Vorgabe.
    Der Punkt liegt auf der Geraden.

    Also kann man es sich wie eine steile Brücke mit Senkrechten Pfeiler vorstellen.
    Die Funktion soll so Aussehen:
    function Vector getPoint(Vector lineA,Vector lineB,float Y);

    Man kann es auch so sagen das man zwei Geraden hat.
    Die eine ist Senkrecht und liegt auf einem X_wert der Koordinate
    Die Andere liegt frei im Raum.
    nun möchte ich den Schnittpunkt finden.

    Ich hoffe das war klarer.



  • y = a*x + b

    bzw.

    x = (y - b)/a

    ???



  • k danke aber ich bin schon ein bisschen zu müde.
    Ich probiers morgen und schreib dann wieder.

    Vielen Dank, hoffentlich klappts.



  • hättest du das nicht auf einem Blatt Papier selbst hinkriegen können?

    So schwer ist das nicht. Wirklich.



  • Sollen lineA und lineB zwei Punkte auf der Geraden sein?

    Dann ist die Gerade meinetwegen parametrisch gegeben durch a + t*(b-a). Der X-Wert soll einen bestimmten Wert haben:

    a_x + t * (b_x-a_x) = x_soll

    =>

    t = (x_soll - a_x)/(b_x-a_x)

    Und das t dann halt in die erste Gleichung einsetzen um den Punkt auf der Geraden zu finden, oder halt nur y bestimmen. Und natürlich so Fälle wie a_x = b_x abfangen...



  • Ich bin halt ne Lusche in Geometrie.
    Vielen Dasnk für die Antworten



  • Hallo alterbro,

    Die mathematische Lösung wurde Dir ja schon gezeigt. Wenn Du das in C++ umsetzt, kannst Du Dir zunutze machen, dass das Skalarprodukt eines Vektors mit den Einheitsvektoren in X- bzw. Y-Richtung jeweils den X- bzw. Y-Wert des Vektors liefern.
    Also zum Beispiel e\_x \cdot \left( \begin{eqnarray} a\_x \\ a\_y \end{eqnarray} \right) = a\_x

    Statt zwei Funktionen jeweils für X und Y zu schreiben, schreibst Du nur eine Funktion und gibst eine Variable Einheitsvektor als Unterscheidung für die Richtung mit - etwa so:

    // --  Einheitsvektoren in X- und Y-Richtung
    class Ex {};
    class Ey {};
    namespace 
    {
        const Ex eX;
        const Ey eY;
    }
    
    template< typename V > 
    Vector getPoint( const Vector& a, const Vector& b, const V& n, double d )
    {
        Vector diff = b-a;
        double t = (d - n * a) / (n * diff);
        return a + t*diff;
    }
    

    Der Aufruf geschieht dann einfach unter Angabe der jeweiligen Richtung - zum Beispiel:

    Vector a( -1, 2 );
        Vector b( 9, 7 );
        Vector pnt = getPoint( a, b, eX, 5.0 );
    

    Damit das funktioniert, muss Deine Vector-Klasse über die notwendigen Operatoren verfügen:

    class Vector
    {
    public:
        Vector( double x, double y )
            : x_(x),  y_(y)
        {}
        Vector operator+( const Vector& b ) const
        {
            return Vector( x_+b.x_, y_+b.y_ );
        }
        Vector operator-( const Vector& b ) const
        {
            return Vector( x_-b.x_, y_-b.y_ );
        }
    
        friend std::ostream& operator<<( std::ostream& out, const Vector& v );
    
        // --   Skalarprodukte
        friend double operator*( Ex, const Vector& v ) { return v.x_; }
        friend double operator*( Ey, const Vector& v ) { return v.y_; }
        friend double operator*( const Vector& a, const Vector& b )
        {
            return a.x_ * b.x_ + a.y_ * b.y_;
        }
    
        // --   Multiplikation Skalar * Vektor
        friend Vector operator*( double factor, const Vector& v )
        {
            return Vector( factor * v.x_, factor * v.y_ );
        }
    
    private:
        double x_, y_;
    };
    

    .. ansonsten siehe auch hier.

    Dieses Vorgehen hat den Vorteil, dass Du mit der identischen Funktion auch den Schnittpunkt mit einer schrägen Wand bestimmen kannst. Du benötigst dazu einen Normalenvektor der Wand und einen beliebigen Punkt auf der Wand. Etwa so:

    // --   Schnittpunkt mit einer Wand
        Vector n(4, -1); // Wandnormale
        Vector wand( 2, 0 ); // ein Punkt der Wand
        pnt = getPoint( a, b, n, n*wand );
    

    .. und da hier keine Einschränkung auf 2Dimensionen gemacht wird (außer in der Vektorklasse selbst) - geht das auch sofort in 3D!

    alterbro schrieb:

    Ich bin halt ne Lusche in Geometrie.

    Versuch' das zu ändern 😉

    Gruß
    Werner


Log in to reply