J'étudiais le traitement de formes, mais je n'arrivais pas à y arriver juste en lisant un livre, alors j'ai décidé d'essayer la programmation.
La courbe de Bézier est une forme courbe créée dans le polygone de contrôle formé en reliant les points de contrôle $ P_i $. Un point qui compose la courbe de Bézier est défini par les points de contrôle et les paramètres, et en les reliant, la courbe de Bézier comme indiqué dans la figure ci-dessous peut être dessinée. Le point bleu est le point de contrôle.
Cette fois, nous ciblons la courbe de Bézier dessinée dans un espace bidimensionnel. Ainsi, la composante de la valeur de coordonnée est $ (X_i, Y_i) $.
Tout d'abord, la courbe de Bézier est définie par la formule suivante. Avec cette formule, une fois que $ t $ est déterminé, le point $ P (t) $ sur la courbe de Bézier peut être calculé. Calculez le point $ P (t) $ en changeant $ t $ dans la plage de 0 à 1, et connectez-les pour former une courbe de Bézier.
P(t) = \sum_{i=0}^{N}B_{N,i}(t)Q_i \tag{1}
B_{n,i}(t) = \begin{pmatrix}n\\i\end{pmatrix}t^i(1-t)^{n-i} \tag{2}
Il existe différents symboles tels que $ t $ et $ N $, mais la signification de chacun est la suivante.
Est l'ordre
Par exemple, si l'ordre est 3, vous pouvez dessiner une courbe de Bézier cubique.
Au fur et à mesure que l'ordre augmente, la forme devient plus compliquée.
Coefficient bimétrique La partie de coefficient calculée sur le côté droit de $ B_ {n, i} (t) $ est appelée le coefficient binomial, et elle est calculée par la formule suivante.
\begin{pmatrix} n\\i \end{pmatrix} = {_n\mathrm{C}_k=\frac{n!}{k!(n-k)!} } \tag{3}
De plus, $ (2) $ est appelé le polymorphisme de Bernstein.
Le script python implémenté est le suivant.
#Calcul du coefficient binaire
def BiCoe(n, k):
if n < k :
return -1
return math.factorial(n) / (math.factorial(k) * math.factorial((n - k)))
#Polypole de Bernstein
def Bernstein(n, i, t):
return BiCoe(n, i) * np.power((1-t), (n-i)) * np.power(t, i)
#Courbe de Bézier
def BezierCurve(points, t):
Gt = 0
n = len(points) - 1
for k, point in enumerate(points):
Gt += point * Bernstein(n, k, t)
return Gt
--Begger partie de dessin de courbe
#Dessiner la courbe de Bézier
def DrawBezierCurve(points):
x = np.arange(0, 1, 0.01, dtype=np.float32)
x = np.append(x, 1.0)
gt = [BezierCurve(points, t) for t in x]
gt_x = [g[0] for g in gt]
gt_y = [g[1] for g in gt]
ct_x = [ct[0] for ct in points]
ct_y = [ct[1] for ct in points]
plt.plot(ct_x, ct_y, linestyle='dashed', linewidth=1)
plt.plot(gt_x, gt_y, linewidth = 3)
plt.scatter(ct_x, ct_y)
Quand j'ai lu ce livre, j'ai trouvé stupide de dire: "Puis-je dessiner une courbe avec cette formule?" Je pense que cela s'est approfondi. En tant que maniaque des mathématiques, il m'a fallu beaucoup de temps pour faire des recherches et comprendre un peu. .. .. Par exemple, il a fallu environ 30 minutes pour savoir que la partie coefficient est un coefficient binomial en regardant la formule de $ (2) $. (LOL) Je vais continuer à étudier dur.
Recommended Posts