Je voulais jouer avec la courbe de Bézier

en premier

Je voulais dessiner une courbe de Bézier en utilisant python, et j'ai pu la dessiner immédiatement. Après cela, j'ai voulu jouer avec la courbe de Bézier de manière interactive, mais je n'ai pas trouvé le code, donc je le posterai avec un mémorandum pour moi-même. Figure-1-2019-11-22-17-45-07.gif

Courbe de Bézier

Pour la courbe de Bézier en trois dimensions, je me suis référé à la formule de cette personne.

matplotlib Pour la partie à afficher de manière interactive, je me suis référé à cette personne. Chaque fois que le point de contrôle est mis à jour, le calcul est recalculé et la courbe est à nouveau affichée.

explication facile

Sur la gauche se trouvent les points de contrôle et la courbe de Bézier. Le rayon de courbure est affiché à droite. L'axe des x du graphique de droite est t (0 <= t <= 1) et l'axe des y est le rayon de courbure.

code

bezier.py


from scipy import integrate
import matplotlib.pyplot as plt
import numpy as np

class Coo():
    def __init__(self,_x,_y):
        self.x = _x
        self.y = _y

class Bezier():
    def __init__(self,_p0,_p1,_p2,_p3):
        self.p = [0]*4
        self.p[0] = _p0
        self.p[1] = _p1
        self.p[2] = _p2
        self.p[3] = _p3

        self.fig = plt.figure(figsize=(10,5))
        self.ax = self.fig.add_subplot(121)#111 1x1 
        self.ax.set_xlim(-1.0 , 11.0)
        self.ax.set_ylim(-1.0 , 11.0)

        self.dax = self.fig.add_subplot(122)#111 1x1 

        self.t = np.arange(0,1,0.01)
        
        self.x = (self.t**3)*self.p[3].x + 3*(self.t**2)*(1-self.t)*self.p[2].x + 3*self.t*((1-self.t)**2)*self.p[1].x + ((1-self.t)**3)*self.p[0].x
        self.y = (self.t**3)*self.p[3].y + 3*(self.t**2)*(1-self.t)*self.p[2].y + 3*self.t*((1-self.t)**2)*self.p[1].y + ((1-self.t)**3)*self.p[0].y
        
        self.dx = 3*((self.t**2)*(self.p[3].x-self.p[2].x)+2*self.t*(1-self.t)*(self.p[2].x-self.p[1].x)+((1-self.t)**2)*(self.p[1].x-self.p[0].x))
        self.dy = 3*((self.t**2)*(self.p[3].y-self.p[2].y)+2*self.t*(1-self.t)*(self.p[2].y-self.p[1].y)+((1-self.t)**2)*(self.p[1].y-self.p[0].y))

        self.ddx = 6*(self.t*(self.p[3].x-2*self.p[2].x+self.p[1].x)+(1-self.t)*(self.p[2].x-2*self.p[1].x+self.p[0].x))
        self.ddy = 6*(self.t*(self.p[3].y-2*self.p[2].y+self.p[1].y)+(1-self.t)*(self.p[2].y-2*self.p[1].y+self.p[0].y))

        self.artists = [0]*4
        self.artists[0], = self.ax.plot([self.p[0].x],[self.p[0].y],marker='.',markersize=10,picker=15,label='p[0]')
        self.artists[1], = self.ax.plot([self.p[1].x],[self.p[1].y],marker='.',markersize=10,picker=15,label='p[1]')
        self.artists[2], = self.ax.plot([self.p[2].x],[self.p[2].y],marker='.',markersize=10,picker=15,label='p[2]')
        self.artists[3], = self.ax.plot([self.p[3].x],[self.p[3].y],marker='.',markersize=10,picker=15,label='p[3]')
        self.ax_artist, = self.ax.plot(self.x,self.y)

        dp = [((x_a-x_b)**2 + (y_a-y_b)**2)*100 for x_a,x_b,y_a,y_b in zip(self.x[:-1],self.x[1:],self.y[:-1],self.y[1:])]
        adp = [(i**2 + j**2)**0.5 for i,j in zip(self.dx,self.dy)]
        addp = [(i**2 + j**2)**0.5 for i,j in zip(self.ddx,self.ddy)]
        R = ((self.dx**2 + self.dy**2)**1.5)/((self.dx*self.ddy - self.ddx*self.dy)**2)**0.5

        self.dax.set_xlim(-0.1 , 1.5)
        self.dax.set_ylim(-1.0 , 40)
        dp.append(0.0)

        integrate_simps = integrate.simps(self.y, self.x)
        self.dax_artist, = self.dax.plot(self.t,R)

        dp_max_index = [i for i, x in enumerate(dp) if x == max(dp)]
        adp_max_index = [i for i, x in enumerate(adp) if x == max(adp)]

    def change(self):
        self.x = (self.t**3)*self.p[3].x + 3*(self.t**2)*(1-self.t)*self.p[2].x + 3*self.t*((1-self.t)**2)*self.p[1].x + ((1-self.t)**3)*self.p[0].x
        self.y = (self.t**3)*self.p[3].y + 3*(self.t**2)*(1-self.t)*self.p[2].y + 3*self.t*((1-self.t)**2)*self.p[1].y + ((1-self.t)**3)*self.p[0].y
        
        self.dx = 3*((self.t**2)*(self.p[3].x-self.p[2].x)+2*self.t*(1-self.t)*(self.p[2].x-self.p[1].x)+((1-self.t)**2)*(self.p[1].x-self.p[0].x))
        self.dy = 3*((self.t**2)*(self.p[3].y-self.p[2].y)+2*self.t*(1-self.t)*(self.p[2].y-self.p[1].y)+((1-self.t)**2)*(self.p[1].y-self.p[0].y))

        self.ddx = 6*(self.t*(self.p[3].x-2*self.p[2].x+self.p[1].x)+(1-self.t)*(self.p[2].x-2*self.p[1].x+self.p[0].x))
        self.ddy = 6*(self.t*(self.p[3].y-2*self.p[2].y+self.p[1].y)+(1-self.t)*(self.p[2].y-2*self.p[1].y+self.p[0].y))
        
        dp = [((x_a-x_b)**2 + (y_a-y_b)**2)*100 for x_a,x_b,y_a,y_b in zip(self.x[:-1],self.x[1:],self.y[:-1],self.y[1:])]
        adp = [(i**2 + j**2)**0.5 for i,j in zip(self.dx,self.dy)]
        addp = [(i**2 + j**2)**0.5 for i,j in zip(self.ddx,self.ddy)]
        R = ((self.dx**2 + self.dy**2)**1.5)/((self.dx*self.ddy - self.ddx*self.dy)**2)**0.5

        self.ax_artist.set_data(self.x,self.y)
        self.dax_artist.set_data(self.t,R)

    def sets(self,_gco,_event):
        for i,j in zip(self.artists,self.p):
            if i == _gco:
                i.set_data(_event.xdata,_event.ydata)
                j.x = _event.xdata
                j.y = _event.ydata
                break
        self.change()


gco = None

if __name__ == '__main__':
    a = Coo(1,1)
    b = Coo(10,1)
    c = Coo(1,5)
    d = Coo(10,5)

    B = Bezier(a,b,c,d)
    
    def motion(event):
        global gco
        if gco is None:
            return
        B.sets(gco,event)
        plt.draw()

    def onpick(event):
        global gco
        gco = event.artist


    def release(event):
        global gco
        gco = None

    plt.connect('motion_notify_event', motion)
    plt.connect('pick_event', onpick)
    plt.connect('button_release_event', release)
    
    plt.show()

J'utilise uniquement les grandes bibliothèques, donc je pense que cela fonctionnera bientôt.

Recommended Posts

Je voulais jouer avec la courbe de Bézier
Je voulais résoudre le concours de programmation Panasonic 2020 avec Python
J'ai capturé le projet Toho avec Deep Learning ... je le voulais.
[Scikit-learn] J'ai joué avec la courbe ROC
Je voulais résoudre ABC160 avec Python
Je veux jouer avec aws avec python
Je voulais résoudre ABC172 avec Python
Je voulais vraiment copier avec du sélénium
Je voulais résoudre le problème ABC164 A ~ D avec Python
Je voulais résoudre NOMURA Contest 2020 avec Python
J'ai essayé de sauvegarder les données avec discorde
Je voulais installer Python 3.4.3 avec Homebrew + pyenv
Je voulais visualiser la simulation de particules 3D avec la bibliothèque de visualisation Python Matplotlib.
J'ai essayé d'entraîner la fonction péché avec chainer
Je voulais aussi vérifier les indices de type avec numpy
J'ai essayé de toucher un fichier CSV avec Python
J'ai essayé de résoudre Soma Cube avec python
Je voulais utiliser la bibliothèque Python de MATLAB
Je veux hériter de l'arrière avec la classe de données python
J'ai essayé de résoudre le problème avec Python Vol.1
Je t'ai écrit pour regarder le signal avec Go
Je voulais juste extraire les données de la date et de l'heure souhaitées avec Django
J'ai essayé d'analyser les émotions de tout le roman "Weather Child" ☔️
Essayez de jouer avec l'uprobe qui prend directement en charge Systemtap
J'ai essayé de trouver la moyenne de plusieurs colonnes avec TensorFlow
J'ai essayé de notifier les informations de retard de train avec LINE Notify
Je veux changer le drapeau japonais en drapeau des Palaos avec Numpy
Ce que j'ai fait pour accueillir le Python2 EOL en toute confiance
[Python] Je souhaite utiliser l'option -h avec argparse
Je n'arrive pas à me connecter à la page d'administration avec Django 3
Je voulais calculer un tableau avec la méthode des subs de Sympy
Je voulais supprimer plusieurs objets en s3 avec boto3
Je voulais faire fonctionner le moteur avec une tarte à la râpe, alors j'ai essayé d'utiliser la carte de commande du moteur de Waveshare
Je veux trouver l'intersection d'une courbe de Bézier et d'une ligne droite (méthode de découpage de Bézier)
Essayez de dessiner une courbe de Bézier
Chaîne de hachage que je voulais éviter (2)
J'ai essayé de calculer l'intégrale de probabilité (I à l'intégrale)
Je voulais faire évoluer cGAN vers ACGAN
J'ai aimé le tweet avec python. ..
Je veux faire ○○ avec les Pandas
Je veux déboguer avec Python
Chaîne de hachage que je voulais éviter (1)
J'ai essayé de déplacer le ballon
J'ai essayé d'estimer la section.
J'ai essayé de décrire le trafic en temps réel avec WebSocket
J'ai essayé de résoudre l'édition du débutant du livre des fourmis avec python
Je veux connaître la météo avec LINE bot avec Heroku + Python
J'ai essayé d'automatiser l'arrosage du pot avec Raspberry Pi
Je voulais créer une présentation intelligente avec Jupyter Notebook + nb present
[Introduction à StyleGAN] J'ai joué avec "The Life of a Man" ♬
Je veux sortir le début du mois prochain avec Python
J'ai essayé de traiter l'image en "style croquis" avec OpenCV
Je voulais contester la classification du CIFAR-10 en utilisant l'entraîneur de Chainer
[Introduction à sinGAN-Tensorflow] J'ai joué avec la super-résolution "Challenge Big Imayuyu" ♬
J'ai essayé de démarrer avec Bitcoin Systre le week-end
J'ai essayé de traiter l'image dans un "style de dessin au crayon" avec OpenCV
J'ai essayé d'agrandir la taille du volume logique avec LVM
Pour le moment, je veux convertir n'importe quel fichier avec ffmpeg !!
Je veux vérifier la position de mon visage avec OpenCV!
J'ai essayé d'améliorer l'efficacité du travail quotidien avec Python