"trouver l'équation d'une droite à partir de deux points"

Soyez le premier à donner votre avis sur cette source.

Snippet vu 32 892 fois - Téléchargée 29 fois

Contenu du snippet

Compilateur: DevCpp et Visual C++ (6,7 ou autres) ...

A partir de deux points ce programme peut trouver l'équation qui lui correspond
et pourquoi pas la déssiner ...

-> Equation cartésiènne de la forme: ax + by + c = 0

-> Vecteur directeur associé à cette droite: v(-b,a)
-b=(pt2.x-pt1.x)
a=(pt2.y-pt1.y)

Voilà, n'ésité pas à laisser des commentaire ...

PS: si vous avez des erreurs de compilation ou autre faite le moi savoir, merci.
(en cas d'inatention en recopiant ce code directement sans le tester )

Source / Exemple :


//////////////////////////////////////////////////////////////////////////
// En-têtes:
//////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <stdio.h>

//////////////////////////////////////////////////////////////////////////
// Classe d'un vecteur 2D:
//////////////////////////////////////////////////////////////////////////
class CVector2D
{
    public:

        CVector2D(){}
        ~CVector2D(){}

        CVector2D(long _x, long _y):x(_x),y(_y){}

        long x,y;
};

//////////////////////////////////////////////////////////////////////////
// Calcul du vecteur directeur de la droite:
//////////////////////////////////////////////////////////////////////////
CVector2D mVector(CVector2D vPoint1, CVector2D vPoint2)
{
    static CVector2D vVector;

    vVector.x=(vPoint2.x-vPoint1.x);
    vVector.y=(vPoint2.y-vPoint1.y);

    return(vVector);
}

//////////////////////////////////////////////////////////////////////////
// Corps du programme:
//////////////////////////////////////////////////////////////////////////
int main(void)
{
    // Initialisation des deux points de la droite delta:
    CVector2D vPoint1=CVector2D(1,2);
    CVector2D vPoint2=CVector2D(4,5);
    
    // Vecteur directeur de composantes (-b,a) de la droite delta:
    CVector2D vVector=mVector(vPoint1,vPoint2);
    
    // Equation de la droite delta du type -> ax + by + c = 0:
    int a =  vVector.y;
    int b = -vVector.x;
    
    // Constante -> c = - (ax + by) ; x et y étant les composantes
    // d'un des deux point de la droite delta:
    int c = -((a*vPoint1.x)+(b*vPoint1.y));
    
    // Ordonne les x:
    if(vPoint1.x>vPoint2.x)
    {
        int tmp_x=vPoint1.x;
        
        vPoint1.x=vPoint2.x;
        vPoint2.x=tmp_x;
    }
    
    // Ordonne les y:
    if(vPoint1.y>vPoint2.y)
    {
        int tmp_y=vPoint1.y;
        
        vPoint1.y=vPoint2.y;
        vPoint2.y=tmp_y;
    }
    
    // Affiche l'équation de la droite delta:
    printf("DELTA: (%d)x + (%d)y + (%d) = 0\n\n", a,b,c);
    
    for(long x=vPoint1.x; x<=vPoint2.x; x++)
    for(long y=vPoint1.y; y<=vPoint2.y; y++)
    {
        // Si l'équation est vérifiée:
        if(a*x+b*y+c==0)
        {
            printf("x = %d -- y = %d\n", x,y);
        }
    }
    
    // Fin:
    printf("\n");
    system("PAUSE");
    return(0);
}

Conclusion :


A vous de jouer ...

A voir également

Ajouter un commentaire

Commentaires

Messages postés
4
Date d'inscription
lundi 20 décembre 2004
Statut
Membre
Dernière intervention
14 janvier 2005

Merci, à vous deux & merci à Kirua,
tu as répondu à ma question (passer par des vecteurs).

Bonne continuation à vous,
Sébastien.
Messages postés
3006
Date d'inscription
dimanche 14 avril 2002
Statut
Membre
Dernière intervention
31 décembre 2008

En 3D et en cartésien, on représente les droites comme des intersections de plans. En règle générale, dans un espace euclidien, on définit une droite ou un plan (ou un hyperplan, mais soit) comme un ensemble de points satisfaisant une contrainte linéaire:

ax + by + c = 0 -> droite en 2D
ax + by + cz + d = 0 -> plan en 3D

Une contrainte fait baisser la dimension de ton objet de 1 par rapport à la dimension de l'espace: une droite a une dimension dans un espace 2D et un plan a deux dimensions dans un espace 3D.

Pour passer d'un espace 3D à un objet qui a une dimension (une droite), il te faut deux contraintes: 3 - 2 = 1. Ces deux contraintes sont les équations de deux plans. L'intersection de ces deux plans est la droite. (essaie de visualiser ça si tu n'es pas convaincu)

C'est difficile de savoir comment rédiger ma réponse puisque je ne connais pas ton niveau en maths, mais disons pour faire simple que: trouver l'équation cartésienne d'une droite en 3D, c'est lourd!

On préférera travailler avec une équation paramétrique: imagine deux points distincts dans l'espace 3D. Ensuite, imagine le vecteur (orienté) qui les relie. Maintenant, imagine que tu multiplies ce vecteur par un scalaire quelconque (un nombre réel): le vecteur va devenir plus ou moins grand ou petit, et même se retourner quand tu multiplies par un nombre négatif. Se faisant, tu vas parcourir tous les points de la droite! Et ça, c'est super simple à gérer :).

Vecteur directeur = point1 - point2; (ou l'inverse, peu importe)

alors, tous les points de la droite sont du type:
double x = ...; (ce que tu veux)
pt_de_la_droite = directeur * x;

Ca te permet de passer en revue les points de la droite. Maintenant, si ce qu'il te faut, c'est calculer des intersections de droites avec d'autres droites ou avec des plans, c'est une autre histoire.

Qu'as-tu besoin de faire?
Messages postés
47
Date d'inscription
lundi 19 avril 2004
Statut
Membre
Dernière intervention
3 mai 2010

L'équation est du type : ax + by + cz + d = 0
Par contre, le calcul de a, b, c et d doit être plus complexe.
Je n'ai pas les équations sous la main, désolé.
Si je les retrouve, je le rajouterais ici.
Messages postés
4
Date d'inscription
lundi 20 décembre 2004
Statut
Membre
Dernière intervention
14 janvier 2005

"En plus, en complétant, on peut aussi travailler dans le domaine 3D voire temporel avec ax + by + cz + d = 0"

>> Comment fait-on pour trouver une droite 3D à partir de 2 points 3D ? -> Cela m'intéresserais !

merci,
merci Thony_c !
Messages postés
47
Date d'inscription
lundi 19 avril 2004
Statut
Membre
Dernière intervention
3 mai 2010

Moi je mets 10/10, parce que vous oubliez un détail.
Lui travaille avec la forme ax + by + c 0, ce qui permet la gestion d'équation de type x 10, contrairement à la forme y = ax + b.

En plus, en complétant, on peut aussi travailler dans le domaine 3D voire temporel avec ax + by + cz + d = 0

La forme ax + by + c = 0 n'utilise pas de division, est donc plus précise et ne donne pas de valeur farfelues quand on approche 0.
La forme caninique est plus souvent utilisée dans le domaine scientifique (physique, aéronautique, ...)

Pour rappel : ax + by + c = 0 avec :
* a = y1 - y2;
* b = x2 - x1;
* c = x1*y2 - x2*y1;

Bravo Thony_c
Afficher les 12 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.