droite dans l'espace

Question

Bonjour,

Quelqu'un connaitrait il un script python qui permette à partir de localisation de différents points dans l'espace(*), de trouver l'équation de la droite qui passe au plus prêt des différents points?

(*)comme par exemple

point 1 x1,y1,z1
point 2 x2,y2,z2
point 3 x3,y3,z3

le nombre de points pouvant varier.

D'avance, merci.

galgafou · Answer

Salut Pythalgo,

G trouvé un site qui pourrait p-e nous aider dans notre démarche... 
C'est: http://www.vbfrance.com/forum/sujet-REGRESSION-LINEAIRE-DROITE-ESPACE_1171532.aspx

Je vais aussi demander conseil à mon prof de Math pour que je comprenne un peu mieux la philosophie du développement et pouvoir écrire un petit script pour automatiser le calcul.

Je te tiens au courant...

Just do it...

galgafou · Answer

Voici le script que tu me demandais. Je me suis dis que les internautes seront pe aussi interesse. Attention, ce programme est dédié au traitement de données provenant d'une structure texte bien précise. Il faudra le modifier pour pouvoir l'utiliser...

# -*- coding: cp1252 -*-

class Application():
    def __init__(self):
        """Construction de la fenetre principale"""

        self.launch = 0
        self.root = Tk()
        self.root.title("Programme de régression linéaire multiple")
        self.root.geometry("200x100+600+300")
        self.frame_1 = Frame(self.root)
        self.frame_1.pack()
        importation = Button(self.frame_1, text="Importer", command = self.importation, font=("Arial Rounded MT Bold", 10)).grid(row=0, column=0, padx=10, pady=10)
        Button(self.frame_1, text="Quitter", command = self.root.quit, font=("Arial Rounded MT Bold", 10)).grid(row=0, column =1, padx=10, pady=10)

        self.root.mainloop()
        self.root.destroy()

    def importation(self):
        """Importation des données contenues dans le fichier texte sélectionné"""
        
        access = tkFileDialog.askopenfilename(title="Importation", filetypes = [("Texte", ".txt")])
        self.text = open(access,'r').readlines()
        
        # supprime les premières lignes ne comprenant pas les infos utiles
        test = "FALSE"
        while test == "FALSE":
            if self.text[0][2] == "#":
                test = "TRUE"
            else:
                del(self.text[0])
        del(self.text[0])

        # création d'une liste qui ne garde que le numero du résidu et les coordonnées X, Y et Z
        text_2 = []
        for cpt in range(len(self.text)):
            text_2.append(self.text[cpt].split())
            for htp in range(len(text_2[cpt])-4):
                del(text_2[cpt][1]) 
        
        self.text = text_2
        self.affichage()

    def affichage(self):
        """Permet l'affichage des données importées"""

        self.root.geometry("500x500")

        if self.launch != 0:
            self.frame_2.destroy()
            self.frame_4.destroy()
        
        self.frame_2 = Frame(self.root)
        self.frame_2.pack()

        self.scrollV = Scrollbar(self.frame_2, orient=VERTICAL)
        self.scrollV.grid(row=0, column=1, sticky=N+S)
        
        self.can Canvas(self.frame_2, yscrollcommand self.scrollV.set)
                    
        self.frame_3 = Frame(self.can)
        self.frame_3.pack()
        Label(self.frame_3, text="résidu", font=("Verdana",10)).grid(row =0, column =1, padx = 10, pady = 5)
        Label(self.frame_3, text="X", font=("Verdana",10)).grid(row =0, column =2, padx = 10, pady = 5)
        Label(self.frame_3, text="Y", font=("Verdana",10)).grid(row =0, column =3, padx = 10, pady = 5)
        Label(self.frame_3, text="Z", font=("Verdana",10)).grid(row =0, column =4, padx = 10, pady = 5)

        # Création de la liste de points 
        self.check = []
        for cpt in range(len(self.text)):
            valueRTS = IntVar()
            chk Checkbutton(self.frame_3, textvariable cpt+1, variable = valueRTS, onvalue = 1, indicatoron = 1, offvalue =0)
            self.check.append(valueRTS)
            chk.grid(row=cpt+1, column=0, padx = 10, pady = 5)
            Label(self.frame_3, text = cpt+1).grid(row=cpt+1, column=1, padx = 10, pady = 5)
            Label(self.frame_3, text=self.text[cpt][1]).grid(row=cpt+1, column=2, padx = 10, pady = 5)
            Label(self.frame_3, text=self.text[cpt][2]).grid(row=cpt+1, column=3, padx = 10, pady = 5)
            Label(self.frame_3, text=self.text[cpt][3]).grid(row=cpt+1, column=4, padx = 10, pady = 5)

        # Paramètrage de la scrollbar
        self.can.grid(row=0, column=0)
        self.scrollV.config(command=self.can.yview)
        self.can.create_window(0,0,window=self.frame_3)
        self.frame_3.update_idletasks()
        self.can.config(scrollregion=self.can.bbox('all'))
        self.can.yview_moveto(0)

        self.frame_4 = Frame(self.root)
        self.frame_4.pack()
        Button(self.frame_4, text="Calculer", command=self.calcul, font=("Arial Rounded MT Bold", 10)).pack()

        self.launch = self.launch + 1
       
    def calcul(self):
        """Fonction qui regroupe les points sélectionnés en vue d'en calculer la meilleure droite"""

        self.points = []
        for cpt in range(len(self.check)):
            if self.check[cpt].get() == 1:
                self.points.append(self.text[cpt])

        if len(self.points) != 0:

            # Création de la matrice Y:
            matrice_Y = len(self.points)*[0]
            for cpt in range(len(self.points)):
                matrice_Y[cpt] = [float(self.points[cpt][2])]
            self.Y = matrix(matrice_Y)
            
            # Création de la matrice Z:
            matrice_Z = len(self.points)*[0]
            for cpt in range(len(self.points)):
                matrice_Z[cpt] = [float(self.points[cpt][3])]
            self.Z = matrix(matrice_Z)
            
            # Création de la matrice X:
            matrice_X = len(self.points)*[0]
            matrice_Xbis = len(self.points)*[0]
            for cpt in range(len(self.points)):
                matrice_X[cpt] = [float(1), float(self.points[cpt][1]), float(self.points[cpt][3])]
                matrice_Xbis[cpt] = [float(1), float(self.points[cpt][1]), float(self.points[cpt][2])]
            self.X = matrix(matrice_X)
            self.Xbis = matrix(matrice_Xbis)
        
            self.plan_1 = regression(self.X,self.Y)
            self.plan_2 = regression(self.Xbis,self.Z)
            self.solution()
        
    def solution(self):

        self.top = Toplevel()
        self.top.title("Solution")
        self.top.geometry("+700+400")
        self.plan_1 = modif_matrice_coeff(self.plan_1,1)
        self.plan_2 = modif_matrice_coeff(self.plan_2,2)
        Label(self.top, text="La droite recherchée est l'intersection des deux plans suivants :").pack()
        Label(self.top, text=self.plan_1).pack()
        Label(self.top, text=self.plan_2).pack()
        Button(self.top, text="Fermer", command= self.top.destroy).pack()
        
        
def modif_matrice_coeff(base,test):
    
    a = str(base[0])
    b = str(base[1])
    c = str(base[2])
    a = a.replace("[","")
    a = a.replace("]","")
    b = b.replace("[","")
    b = b.replace("]","")
    c = c.replace("[","")
    c = c.replace("]","")
    if test == 1:
        plan "y " + a + " + " + b + "x + " + c + "z"
    if test == 2:
        plan "z " + a + " + " + b + "x + " + c + "y"

    return plan

def regression(X,Y):
    
    X_prime = X.T
    Xp_Y = X_prime * Y
    Xp_X = X_prime * X
    Xp_X1 = Xp_X.I
    coeff = Xp_X1 * Xp_Y

    return coeff
                  

if __name__ == "__main__":
    from Tkinter import *
    from numpy import *
    import tkFileDialog
    f = Application()

Just do it...

Droite dans l'espace

2 réponses

Votre réponse