def kurve_berechnen(self):
self.kurvenpunkte_4 = mlab.points3d(
self.x_p, self.y_p, self.z_p, mode="sphere", color=(0, 0, 0), scale_factor=0.02
)
# TODO: ich muss tckp_berechnen die richtigen werte uebergeben
# also nicht index_u sondern u_f4
self.u_f4 = [
self.u_f[self.index_u[0]][self.index_v[0]],
self.u_f[self.index_u[1]][self.index_v[1]],
self.u_f[self.index_u[2]][self.index_v[2]],
self.u_f[self.index_u[3]][self.index_v[3]],
]
self.v_f4 = [
self.v_f[self.index_u[0]][self.index_v[0]],
self.v_f[self.index_u[1]][self.index_v[1]],
self.v_f[self.index_u[2]][self.index_v[2]],
self.v_f[self.index_u[3]][self.index_v[3]],
]
self.tckp = tckp_berechnen(self.u_f4, self.v_f4, 3, 3.0)
# t ist der parameter der kurve
self.t = r_[0:1:101j]
self.t_index = r_[0:101:1]
# xnew, ynew, znew repraesentieren die x, y, z Koordinaten der Kurve
self.xnew, self.ynew, self.znew = self.K(self.t, self.tckp)
# Zeichnet die Kurve nach den Punkten.
self.kurve = mlab.plot3d(self.xnew, self.ynew, self.znew, tube_radius=0.005, color=(1, 1, 1), name="Kurve")
# a, b, c sind die Koeffizienten fuer die Tangentenvektoren
self.a, self.b, self.c = self.dKt(self.t, self.tckp)
self.a_n, self.b_n, self.c_n = normalisiere(self.a, self.b, self.c)
# Das ist der Vektor der zweiten Ableitung der Splinekurve.
# Dieser Vektor liegt ebenfalls in der Tangentialebene.
self.d, self.e, self.f = self.dKtt(self.t, self.tckp)
self.d_n, self.e_n, self.f_n = normalisiere(self.d, self.e, self.f)
# Das ist der Binormalenvektor(blau).
self.g, self.h, self.i = kreuzprodukt(self.a, self.b, self.c, self.d, self.e, self.f)
self.g_n, self.h_n, self.i_n = normalisiere(self.g, self.h, self.i)
# Das ist der Hauptnormalenvektor(gruen).
self.j, self.k, self.l = kreuzprodukt(self.g, self.h, self.i, self.a, self.b, self.c)
self.j_n, self.k_n, self.l_n = normalisiere(self.j, self.k, self.l)
#
# t: h+b, h-b, -h-b, -h+b, h+b
#
# Zeichnet die Tangenten(rot) an die Kurve.
self.tangente = mlab.quiver3d(
self.xnew[0], self.ynew[0], self.znew[0], self.a[0], self.b[0], self.c[0], color=(1, 0, 0), name="Tangente"
)
self.ableitung2 = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.d[0],
self.e[0],
self.f[0],
color=(1, 0.65, 0),
name="2 Ableitung",
)
self.hauptnormale = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.j[0],
self.k[0],
self.l[0],
color=(0, 1, 0),
name="Hauptnormale",
)
self.binormale = mlab.quiver3d(
self.xnew[0], self.ynew[0], self.znew[0], self.g[0], self.h[0], self.i[0], color=(0, 0, 1), name="Binormale"
)
self.normalebene = ebene(
self.xnew,
self.ynew,
self.znew,
self.j_n,
self.k_n,
self.l_n,
self.g_n,
self.h_n,
self.i_n,
(1, 0, 0),
0,
"Normalebene",
)
self.schmiegebene = ebene(
self.xnew,
self.ynew,
self.znew,
self.a_n,
self.b_n,
self.c_n,
self.j_n,
self.k_n,
self.l_n,
(0, 0, 1),
0,
"Schmiegebene",
)
self.rektifizierendeebene = ebene(
self.xnew,
self.ynew,
self.znew,
self.a_n,
self.b_n,
self.c_n,
self.g_n,
self.h_n,
self.i_n,
(0, 1, 0),
0,
"Rektifizierende Ebene",
)
# eckpunkte der normalebene, schmiegebene, rektifizierendeebene
self.epxn, self.epyn, self.epzn = eckpunkte_ebene(
self.xnew, self.ynew, self.znew, self.j_n, self.k_n, self.l_n, self.g_n, self.h_n, self.i_n
)
self.epxs, self.epys, self.epzs = eckpunkte_ebene(
self.xnew, self.ynew, self.znew, self.a_n, self.b_n, self.c_n, self.j_n, self.k_n, self.l_n
)
self.epxr, self.epyr, self.epzr = eckpunkte_ebene(
self.xnew, self.ynew, self.znew, self.a_n, self.b_n, self.c_n, self.g_n, self.h_n, self.i_n
)
# Tangente an die Isoparameterlinie in Abhaengigkeit
# vom Flaechenparameter u
self.u1, self.u2, self.u3 = self.dKu(self.t, self.tckp)
self.u1_n, self.u2_n, self.u3_n = normalisiere(self.u1, self.u2, self.u3)
# Tangente an die Isoparameterlinie in Abhaengigkeit
# vom Flaechenparameter v
self.v1, self.v2, self.v3 = self.dKv(self.t, self.tckp)
self.v1_n, self.v2_n, self.v3_n = normalisiere(self.v1, self.v2, self.v3)
# Normalenvektor zur Flaeche.
self.uv1, self.uv2, self.uv3 = kreuzprodukt(self.u1, self.u2, self.u3, self.v1, self.v2, self.v3)
# Normaleneinheitsvektor zur Flaeche.
# Damit der Normaleneinheitsvektor immer von der Flaeche weg
# zeigt, muss ich wohl den Absulut Wert der
# Tangentenvektoren u, v nehmen.
self.uv1_n, self.uv2_n, self.uv3_n = normalisiere(self.uv1, self.uv2, self.uv3)
self.tangente_fu = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.u1[0],
self.u2[0],
self.u3[0],
color=(1, 0.65, 0),
name="Tangente u",
)
self.tangente_fv = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.v1[0],
self.v2[0],
self.v3[0],
color=(1, 0.65, 0),
name="Tangente v",
)
self.normale_f = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.uv1[0],
self.uv2[0],
self.uv3[0],
color=(1, 1, 0),
name="Flaechennormale",
)
# Berechnung der Eckpunkte der Tangentialebene der Flaeche.
self.epxt, self.epyt, self.epzt = eckpunkte_ebene(
self.xnew, self.ynew, self.znew, self.u1_n, self.u2_n, self.u3_n, self.v1_n, self.v2_n, self.v3_n
)
self.tangentialebene_f = ebene(
self.xnew,
self.ynew,
self.znew,
self.u1_n,
self.u2_n,
self.u3_n,
self.v1_n,
self.v2_n,
self.v3_n,
(1, 1, 0),
0,
"Tangentialebene der Flaeche",
)
# Fundamentalgroessen der zweiten Fundamentalform
self.n = array([self.uv1_n, self.uv2_n, self.uv3_n])
self.A = self.A_n(self.t, self.tckp) * self.n
self.B1 = self.B1_n(self.t, self.tckp) * self.n
self.B2 = self.B2_n(self.t, self.tckp) * self.n
self.C = self.C_n(self.t, self.tckp) * self.n
self.G = self.Gf(self.t, self.tckp)
self.H = self.Hf(self.t, self.tckp)
self.I = self.If(self.t, self.tckp)
# Normalkruemmung
self.du_werte = du(self.t, self.tckp)
self.dv_werte = dv(self.t, self.tckp)
self.du_2 = self.du_werte ** 2
self.dv_2 = self.dv_werte ** 2
self.k_nf = (
(self.A[0] + self.A[1] + self.A[2]) * self.du_2
+ ((self.B1[0] + self.B1[1] + self.B1[2]) + (self.B2[0] + self.B2[1] + self.B2[2]))
* self.du_werte
* self.dv_werte
+ (self.C[0] + self.C[1] + self.C[2]) * self.dv_2
) / (
(self.G[0] + self.G[1] + self.G[2]) * self.du_2
+ 2 * (self.H[0] + self.H[1] + self.H[2]) * self.du_werte * self.dv_werte
+ (self.I[0] + self.I[1] + self.I[2]) * self.dv_2
)
self.kn_nf = self.k_nf * self.n
self.normalkruemmung = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.kn_nf[0][0],
self.kn_nf[1][0],
self.kn_nf[2][0],
scale_factor=self.k_nf[0],
color=(0, 0, 0),
name="Normalkruemmung",
)
self.s = bogenlaenge(
self.t, self.t_index, self.G, self.H, self.I, self.du_werte, self.dv_werte, self.du_2, self.dv_2
)
self.dKs_werte = self.dKt(self.s, self.tckp)
self.dKss_werte = self.dKtt(self.s, self.tckp)
# vektor der geodaetischen ist richtig durch kg = n x t, aber
# die laenge stimmt nicht
self.kg = kreuzprodukt(self.n[0], self.n[1], self.n[2], self.a_n, self.b_n, self.c_n)
# self.kg[0], self.kg[1], self.kg[2] = positivevektorausrichtung(
# self.kg[0], self.kg[1], self.kg[2])
self.geodaetischekruemmung = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.kg[0][0],
self.kg[1][0],
self.kg[2][0],
color=(1, 0, 1),
name="geodaetische Kruemmung",
)
# TODO: geodaetische Kruemmung berechnen und dann die Summe der
# beiden Krummungen berechnen.
# ob ich die geodaetische Kruemmung nach dem spatprodukt rechnen kann?
# siehe seite 169
# TODO: Kruemmung der Flaeche berechnen.
self.tangente._hideshow()
self.ableitung2._hideshow()
self.hauptnormale._hideshow()
self.binormale._hideshow()
self.tangente_fu._hideshow()
self.tangente_fv._hideshow()
self.normale_f._hideshow()
self.normalkruemmung._hideshow()
self.normalebene._hideshow()
self.schmiegebene._hideshow()
self.rektifizierendeebene._hideshow()
self.tangentialebene_f._hideshow()
self.geodaetischekruemmung._hideshow()
def kurve_berechnen(self):
self.kurvenpunkte_4 = mlab.points3d(
self.x_p, self.y_p, self.z_p, mode="sphere", color=(0, 0, 0), scale_factor=0.02
)
# TODO: ich muss tckp_berechnen die richtigen werte uebergeben
# also nicht index_u sondern u_f4
# wobei u_f4 = [u_f[index_u[0]][index_v[0]], u_f[index_u[1]][index_v[1]], u_f[index_u[2]][index_v[2]], u_f[index_u[3]][index_v[3]]
## self.tckp = tckp_berechnen(self.index_u, self.index_v, 3, 3.0)
self.u_f4 = [
self.u_f[self.index_u[0]][self.index_v[0]],
self.u_f[self.index_u[1]][self.index_v[1]],
self.u_f[self.index_u[2]][self.index_v[2]],
self.u_f[self.index_u[3]][self.index_v[3]],
]
self.v_f4 = [
self.v_f[self.index_u[0]][self.index_v[0]],
self.v_f[self.index_u[1]][self.index_v[1]],
self.v_f[self.index_u[2]][self.index_v[2]],
self.v_f[self.index_u[3]][self.index_v[3]],
]
self.tckp = tckp_berechnen(self.u_f4, self.v_f4, 3, 3.0)
## print self.index_u, self.index_v
# t ist der parameter der kurve
self.t = r_[0:1:101j]
###################### neu
self.t_index = r_[0:101:1]
###################### neu ende
# xnew,ynew,znew representieren die x,y,z Koordinaten der Kurve
self.xnew, self.ynew, self.znew = self.K(self.t, self.tckp)
## print 'xnew,ynew,znew'
## print self.xnew, self.ynew, self.znew
# Zeichnet die Kurve nach den Punkten.
self.kurve = mlab.plot3d(self.xnew, self.ynew, self.znew, tube_radius=0.005, color=(1, 1, 1), name="Kurve")
# a,b,c sind die Koeffizienten fuer die Tangentenvektoren
self.a, self.b, self.c = self.dKt(self.t, self.tckp)
self.a_n, self.b_n, self.c_n = normalisiere(self.a, self.b, self.c)
## self.a_n, self.b_n, self.c_n = a,b,c
# Das ist der Vektor der zweiten Ableitung der Splinekurve.
# Dieser Vektor liegt ebenfalls in der Tangentialebene.
self.d, self.e, self.f = self.dKtt(self.t, self.tckp)
self.d_n, self.e_n, self.f_n = normalisiere(self.d, self.e, self.f)
## self.d_n, self.e_n, self.f_n = d,e,f
# Das ist der Binormalenvektor(blau).
## self.g,self.h,self.i = kreuzprodukt(self.a_n, self.b_n, self.c_n, self.d_n, self.e_n, self.f_n)
self.g, self.h, self.i = kreuzprodukt(self.a, self.b, self.c, self.d, self.e, self.f)
self.g_n, self.h_n, self.i_n = normalisiere(self.g, self.h, self.i)
## self.g_n, self.h_n, self.i_n = g,h,i
# Das ist der Hauptnormalenvektor(gruen).
## j,k,l = kreuzprodukt(self.g_n, self.h_n, self.i_n, self.a_n, self.b_n, self.c_n)
self.j, self.k, self.l = kreuzprodukt(self.g, self.h, self.i, self.a, self.b, self.c)
self.j_n, self.k_n, self.l_n = normalisiere(self.j, self.k, self.l)
## self.j_n, self.k_n, self.l_n = j, k, l
#
# t: h+b,h-b,-h-b,-h+b,h+b
#
# Zeichnet die Tangenten(rot) an die Kurve.
## self.tangente = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.a_n[0], self.b_n[0], self.c_n[0], color=(1,0,0), name='Tangente')
## self.ableitung2 = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.d_n[0], self.e_n[0], self.f_n[0], color=(0.6,0.6,0.6), name='2 Ableitung')
## self.hauptnormale = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.j_n[0], self.k_n[0], self.l_n[0], color=(0,1,0), name='Hauptnormale')
## self.binormale = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.g_n[0], self.h_n[0], self.i_n[0], color=(0,0,1), name='Binormale')
self.tangente = mlab.quiver3d(
self.xnew[0], self.ynew[0], self.znew[0], self.a[0], self.b[0], self.c[0], color=(1, 0, 0), name="Tangente"
)
self.ableitung2 = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.d[0],
self.e[0],
self.f[0],
color=(1, 0.65, 0),
name="2 Ableitung",
)
self.hauptnormale = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.j[0],
self.k[0],
self.l[0],
color=(0, 1, 0),
name="Hauptnormale",
)
self.binormale = mlab.quiver3d(
self.xnew[0], self.ynew[0], self.znew[0], self.g[0], self.h[0], self.i[0], color=(0, 0, 1), name="Binormale"
)
self.normalebene = ebene(
self.xnew,
self.ynew,
self.znew,
self.j_n,
self.k_n,
self.l_n,
self.g_n,
self.h_n,
self.i_n,
(1, 0, 0),
0,
"Normalebene",
)
self.schmiegebene = ebene(
self.xnew,
self.ynew,
self.znew,
self.a_n,
self.b_n,
self.c_n,
self.j_n,
self.k_n,
self.l_n,
(0, 0, 1),
0,
"Schmiegebene",
)
self.rektifizierendeebene = ebene(
self.xnew,
self.ynew,
self.znew,
self.a_n,
self.b_n,
self.c_n,
self.g_n,
self.h_n,
self.i_n,
(0, 1, 0),
0,
"Rektifizierende Ebene",
)
# eckpunkte der normalebene, schmiegebene, rektifizierendeebene
self.epxn, self.epyn, self.epzn = eckpunkte_ebene(
self.xnew, self.ynew, self.znew, self.j_n, self.k_n, self.l_n, self.g_n, self.h_n, self.i_n
)
self.epxs, self.epys, self.epzs = eckpunkte_ebene(
self.xnew, self.ynew, self.znew, self.a_n, self.b_n, self.c_n, self.j_n, self.k_n, self.l_n
)
self.epxr, self.epyr, self.epzr = eckpunkte_ebene(
self.xnew, self.ynew, self.znew, self.a_n, self.b_n, self.c_n, self.g_n, self.h_n, self.i_n
)
# Tangente an die Isoparameterlinier in Abhaengigkeit von dem Flaechenparameter u
self.u1, self.u2, self.u3 = self.dKu(self.t, self.tckp)
self.u1_n, self.u2_n, self.u3_n = normalisiere(self.u1, self.u2, self.u3)
# Tangente an die Isoparameterlinier in Abhaengigkeit von dem Flaechenparameter v
self.v1, self.v2, self.v3 = self.dKv(self.t, self.tckp)
self.v1_n, self.v2_n, self.v3_n = normalisiere(self.v1, self.v2, self.v3)
# neu
## matrix1 = positivevektorausrichtung(self.u1_n,self.u2_n,self.u3_n)
## self.u1_n,self.u2_n,self.u3_n = positivevektorausrichtung(self.u1_n,self.u2_n,self.u3_n)
## print 'umatrix'
## print matrix1
## self.u1_n,self.u2_n,self.u3_n = array([self.u1_n,self.u2_n,self.u3_n])*matrix1
## print 'u'
## print vektorausrichtung(self.u1_n,self.u2_n,self.u3_n)
## self.v1_n,self.v2_n,self.v3_n = positivevektorausrichtung(self.v1_n,self.v2_n,self.v3_n)
## matrix1 = positivevektorausrichtung(self.v1_n,self.v2_n,self.v3_n)
## self.v1_n,self.v2_n,self.v3_n = array([self.v1_n,self.v2_n,self.v3_n])*matrix1
## print 'vmatrix'
## print matrix1
## print 'v'
## print vektorausrichtung(self.v1_n,self.v2_n,self.v3_n)
# neu ende
## self.u1_n,self.u2_n,self.u3_n = positivevektorausrichtung(self.u1_n,self.u2_n,self.u3_n)
## self.v1_n,self.v2_n,self.v3_n = positivevektorausrichtung(self.v1_n,self.v2_n,self.v3_n)
# Normalenvektor zur Flaeche.
self.uv1, self.uv2, self.uv3 = kreuzprodukt(self.u1, self.u2, self.u3, self.v1, self.v2, self.v3)
## self.uv1,self.uv2,self.uv3 = kreuzprodukt(self.u1_n,self.u2_n,self.u3_n,self.v1_n,self.v2_n,self.v3_n)
# Normaleneinheitsvektor zur Flaeche.
# Damit der Normaleneinheitsvektor immer von der Flaeche weg zeigt, muss ich wohl den Absulut Wert von den Tangentenvektoren u,v nehmen.
self.uv1_n, self.uv2_n, self.uv3_n = normalisiere(self.uv1, self.uv2, self.uv3)
## self.tangente_fu = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.u1_n[0], self.u2_n[0], self.u3_n[0], color=(1,0,1), name='Tangente u')
## self.tangente_fv = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.v1_n[0], self.v2_n[0], self.v3_n[0], color=(1,0,1), name='Tangente v')
## self.normale_f = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.uv1_n[0], self.uv2_n[0], self.uv3_n[0], color=(1,1,0), name='Flaechennormale')
self.tangente_fu = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.u1[0],
self.u2[0],
self.u3[0],
color=(1, 0.65, 0),
name="Tangente u",
)
self.tangente_fv = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.v1[0],
self.v2[0],
self.v3[0],
color=(1, 0.65, 0),
name="Tangente v",
)
self.normale_f = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.uv1[0],
self.uv2[0],
self.uv3[0],
color=(1, 1, 0),
name="Flaechennormale",
)
# Berechnung der Eckpunkte der Tangentialebene der Flaeche.
self.epxt, self.epyt, self.epzt = eckpunkte_ebene(
self.xnew, self.ynew, self.znew, self.u1_n, self.u2_n, self.u3_n, self.v1_n, self.v2_n, self.v3_n
)
self.tangentialebene_f = ebene(
self.xnew,
self.ynew,
self.znew,
self.u1_n,
self.u2_n,
self.u3_n,
self.v1_n,
self.v2_n,
self.v3_n,
(1, 1, 0),
0,
"Tangentialebene der Flaeche",
)
# Fundamentalgroessen der zweiten Fundamentalform
self.n = array([self.uv1_n, self.uv2_n, self.uv3_n])
## self.n = array([self.uv1,self.uv2,self.uv3])
### neu
## print 'u1-u3'
## print self.u1
## print
## print self.u2
## print
## print self.u3
## print 'v1-v3'
## print self.v1
## print
## print self.v2
## print
## print self.v3
## print 'vektorlaenge u v'
## print vektorausrichtung(self.u1,self.u2,self.u3)
## print
## print vektorausrichtung(self.v1,self.v2,self.v3)
## print 'vektorlaenge ende'
# hier sollte ich lieber anstelle von n gleich u und v vektor
# in positive ausrichtung bringen
## print 'richtung n'
## print vektorausrichtung(self.n[0],self.n[1],self.n[2])
## matrix1 = abs(vektorausrichtung(self.n[0],self.n[1],self.n[2]))/vektorausrichtung(self.n[0],self.n[1],self.n[2])
## print 'matrix1'
## print matrix1
## self.n = self.n*matrix1
## print 'neue n'
## print self.n
## self.uv1_n = self.n[0]
## self.uv2_n = self.n[1]
## self.uv3_n = self.n[2]
## self.normale_f = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.uv1_n[0], self.uv2_n[0], self.uv3_n[0], color=(1,1,0), name='Flaechennormale')
## self.n = abs(self.n)
### neu ende
self.A = self.A_n(self.t, self.tckp) * self.n
self.B1 = self.B1_n(self.t, self.tckp) * self.n
self.B2 = self.B2_n(self.t, self.tckp) * self.n
self.C = self.C_n(self.t, self.tckp) * self.n
self.G = self.Gf(self.t, self.tckp)
self.H = self.Hf(self.t, self.tckp)
self.I = self.If(self.t, self.tckp)
# Normalkruemmung
self.du_werte = du(self.t, self.tckp)
self.dv_werte = dv(self.t, self.tckp)
self.du_2 = self.du_werte ** 2
self.dv_2 = self.dv_werte ** 2
self.k_nf = (
(self.A[0] + self.A[1] + self.A[2]) * self.du_2
+ ((self.B1[0] + self.B1[1] + self.B1[2]) + (self.B2[0] + self.B2[1] + self.B2[2]))
* self.du_werte
* self.dv_werte
+ (self.C[0] + self.C[1] + self.C[2]) * self.dv_2
) / (
(self.G[0] + self.G[1] + self.G[2]) * self.du_2
+ 2 * (self.H[0] + self.H[1] + self.H[2]) * self.du_werte * self.dv_werte
+ (self.I[0] + self.I[1] + self.I[2]) * self.dv_2
)
## self.kn_nf = abs(self.k_nf)*self.n*(-1)
## self.k_nf = abs(self.k_nf)
self.kn_nf = self.k_nf * self.n
## self.k_nf = abs(self.k_nf)
## self.kn_nf = self.k_nf*self.n
## self.kn_nf = abs(self.k_nf)*self.n
self.normalkruemmung = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.kn_nf[0][0],
self.kn_nf[1][0],
self.kn_nf[2][0],
scale_factor=self.k_nf[0],
color=(0, 0, 0),
name="Normalkruemmung",
)
################################# neu
## self.dKtt_laenge = vektorlaenge(d,e,f)
#### self.kruemmung = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.d_n[0], self.e_n[0], self.f_n[0], scale_factor=self.dKtt_laenge[0], color=(0.6,0.6,0.6), name='Flaechenkruemmung')
## self.kruemmung = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.d_n[0], self.e_n[0], self.f_n[0], color=(0.6,0.6,0.6), name='Flaechenkruemmung')
## self.kg_laenge = self.dKtt_laenge - self.k_nf
## self.kg = array([d - self.kn_nf[0], e - self.kn_nf[1], f - self.kn_nf[2]])
#### self.geodaetischekruemmung = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.kg[0][0], self.kg[1][0], self.kg[2][0], scale_factor=self.kg_laenge[0], color=(0.6,0.6,0.6), name='geodaetische Kruemmung')
## self.geodaetischekruemmung = mlab.quiver3d(self.xnew[0], self.ynew[0], self.znew[0], self.kg[0][0], self.kg[1][0], self.kg[2][0], color=(0.6,0.6,0.6), name='geodaetische Kruemmung')
####### test
## n_nicht = vektorlaenge(self.uv1,self.uv2,self.uv3)
## test_laenge = self.dKtt_laenge - n_nicht
## print ''
## print 'test_laenge'
## print test_laenge
## print 'n_nicht'
## print n_nicht
####### test ende
################################# neu ende
############################################# neu
self.s = bogenlaenge(
self.t, self.t_index, self.G, self.H, self.I, self.du_werte, self.dv_werte, self.du_2, self.dv_2
)
self.dKs_werte = self.dKt(self.s, self.tckp)
self.dKss_werte = self.dKtt(self.s, self.tckp)
#### self.G = self.Gf(self.s,self.tckp)
#### self.H = self.Hf(self.s,self.tckp)
#### self.I = self.If(self.s,self.tckp)
## spatprodukt_werte = spatprodukt(self.n[0],self.n[1],self.n[2], self.dKs_werte[0],self.dKs_werte[1],self.dKs_werte[2], self.dKss_werte[0],self.dKss_werte[1],self.dKss_werte[2])
## self.kg = vektorlaenge(spatprodukt_werte[0],spatprodukt_werte[1],spatprodukt_werte[2])
## print 'kg'
## print self.kg
## print 's'
## print self.s
## print 'dKss_werte'
## print self.dKss_werte
## print 'dKss_werte laenge'
## print vektorlaenge(self.dKss_werte[0],self.dKss_werte[1],self.dKss_werte[2])
## print 'dKss_werte_normalisiert'
## print normalisiere(self.dKss_werte[0],self.dKss_werte[1],self.dKss_werte[2])
############## test
## self.du_werte = du(self.s,self.tckp)
## self.dv_werte = dv(self.s,self.tckp)
## self.du_2 = self.du_werte**2
## self.dv_2 = self.dv_werte**2
## self.A = self.A_n(self.s,self.tckp) * self.n
## self.B1 = self.B1_n(self.s,self.tckp) * self.n
## self.B2 = self.B2_n(self.s,self.tckp) * self.n
## self.C = self.C_n(self.s,self.tckp) * self.n
## my_k_nf = (self.A[0]+self.A[1]+self.A[2])*self.du_2+((self.B1[0]+self.B1[1]+self.B1[2])+(self.B2[0]+self.B2[1]+self.B2[2]))*self.du_werte*self.dv_werte+(self.C[0]+self.C[1]+self.C[2])*self.dv_2
## print 'my_k_nf'
## print my_k_nf
## self.xnew, self.ynew, self.znew = self.K(self.s, self.tckp)
## #Zeichnet die Kurve nach den Punkten.
## mlab.plot3d(self.xnew, self.ynew, self.znew, tube_radius=0.005, color=(0,0,0), name='Kurve2')
############## test ende
############################################# neu ende
##### neu vektor der geodaetischen ist richtig durch kg = n x t, aber die laenge stimmt nicht
self.kg = kreuzprodukt(self.n[0], self.n[1], self.n[2], self.a_n, self.b_n, self.c_n)
## self.kg[0],self.kg[1],self.kg[2] = positivevektorausrichtung(self.kg[0], self.kg[1], self.kg[2])
self.geodaetischekruemmung = mlab.quiver3d(
self.xnew[0],
self.ynew[0],
self.znew[0],
self.kg[0][0],
self.kg[1][0],
self.kg[2][0],
color=(1, 0, 1),
name="geodaetische Kruemmung",
)
## print
## print 'ausrichtung kg'
## print positivevektorausrichtung(self.kg[0], self.kg[1], self.kg[2])
##### neu ende
### neu print
## print 'flaechennormale n'
## print self.n
## print 'flaechennormale n absolut'
## print abs(self.n)
## print 'd,e,f'
## print self.d, self.e, self.f
## print 'vektorlaenge'
## print vektorlaenge(self.d, self.e, self.f)
### neu print ende
# TODO: geodaetische Kruemmung berechnen und dann die Summe der beiden Krummungen berechnen.
# ob ich die geodaetische Kruemmung nach dem spatprodukt rechnen kann? siehe seite 169
# TODO: Kruemmung der Flaeche berechnen.
self.tangente._hideshow()
self.ableitung2._hideshow()
self.hauptnormale._hideshow()
self.binormale._hideshow()
self.tangente_fu._hideshow()
self.tangente_fv._hideshow()
self.normale_f._hideshow()
self.normalkruemmung._hideshow()
self.normalebene._hideshow()
self.schmiegebene._hideshow()
self.rektifizierendeebene._hideshow()
self.tangentialebene_f._hideshow()
###################################### neu
self.geodaetischekruemmung._hideshow()
