Regelflächen

Beispiele für Regelflächen

Regelflächen entstehen - anschaulich - indem eine Gerade an einer i.allg. regulären Kurve entlanggeführt wird.

zylinderalpha[u_] := {Sin[u], Cos[u], 1}   
ParametricPlot3D[zylinderalpha[u] // Evaluate, {u, 0, 2  Pi}, 
        Axes -> None];

zylinderbeta[u_] := {0, 0, 1}   
ParametricPlot3D[
        zylinderalpha[u] + v zylinderbeta[u] // Evaluate, {u, 0, 
          2  Pi}, {v, -1, 1}, Axes -> None, 
        Boxed -> False];

Wie hier werden wir auch im folgenden mit ...alpha die Leitkurve und mit ...beta das dazugehörige Vektorfeld bezeichnen.

Das Helicoid entsteht als Regelfläche, indem eine horizontale Gerade sich mit konstanter Geschwindigkeit um die z-Achse dreht und sich dabei an ihr entlangbewegt.

Helicoid[a_, b_, c_][u_, v_] := {a*v*Cos[u], b*v*Sin[u], 
        c*u}

ParametricPlot3D[
        Evaluate[Helicoid[1, 1, 1][u, v]], {u, -2 Pi, 
          1  Pi}, {v, -4, 4}, PlotPoints -> {80, 15}, 
        Axes -> None, Boxed -> False];

Das Möbiusband ist eine nicht orientierbare Fläche, die sich leicht als Regelfläche parametrisieren läßt:

Möbius[a_][u_, 
        v_] := {a*(Cos[u] + v*Cos[u/2]*Cos[u]), 
        a*(Sin[u] + v*Cos[u/2]*Sin[u]), a*v*Sin[u/2]}

ParametricPlot3D[
        Evaluate[Möbius[2][u, v]], {u, 0, 
          2  Pi}, {v, - .5,  .5}, PlotPoints -> {80, 15}, 
        Axes -> None, Boxed -> False];

Whitney's Regenschirm ist eine singuläre Fläche.

WhitneyUmbrella[u_, v_] := {u*v, u, v^2}

ParametricPlot3D[
        Evaluate[
          WhitneyUmbrella[u, v]], {u, - .5,  .5}, {v, - .5,  .5},  
        Axes -> None,  Boxed -> False];

Ein elliptischer Hyperboloid.

ellipse[a_, b_][u_] := {a Cos[u], b Sin[u], 0}

ellipticalhyperboloidplus[a_, b_, c_][u_, 
        v_] := ellipse[a, b][u] + 
        v (ellipse[a, b]'[u] + {0, 0, c})

ellipticalhyperboloidminus[a_, b_, c_][u_, 
        v_] := ellipse[a, b][u] - 
        v (ellipse[a, b]'[u] + {0, 0, -c})

ParametricPlot3D[ellipticalhyperboloidplus[1, 2, 3][u, v] // 
          Evaluate, {u, 0, 3  Pi/2}, {v, -1.5, 1.5}, Axes -> None, 
        Boxed -> False];

ParametricPlot3D[ellipticalhyperboloidminus[1, 2, 3][u, v] // 
          Evaluate, {u, 0, 3  Pi/2}, {v, -1.5, 1.5}, Axes -> None, 
        Boxed -> False];

Die Tangentenfläche entsteht, wenn man für das Vektorfeld die Ableitung der Leitkurve wählt.
Eine Helix ist ein Kreis (bzw. mehrere übereinander), der entlang der z-Achse nach oben gezogen wird (an einem Punkt durchgetrennt, dort angefaßt und dieser Punkt dann nach oben gezogen.)

tandev[curve_][u_, v_] := 
      curve[u] + 
        v D[curve[u], u]/
            Sqrt[D[curve[u], u]  .  D[curve[u], u]]

helix[a_, b_][t_]:={a Cos[t], a Sin[t], 
        b t}

ParametricPlot3D[helix[1, 0.4][u] // Evaluate, {u, 0, 4  Pi}, 
        Boxed -> False,  Axes -> False];

ParametricPlot3D[tandev[helix[1, 0.4]][u, v] // Evaluate, {u, 0, 
          4  Pi}, {v, -2, 2}, PlotPoints -> {40, 10}, 
        Axes -> None, Boxed -> False];

Animationen für Regelflächen

animate[alpha_, beta_, u1_, u2_, v1_, v2_, step_, options___] := 
        Block[{t}, 
For[t = step, t < 1 + step/2, 
            t += step, 
{ParametricPlot3D[
                alpha[u] + v beta[u] // Evaluate, 
{u, u1, 
                  u1 + t (u2 - u1)}, {v, v1, v2}, Boxed -> False, 
                Axes -> False, ImageSize -> {400, 400}, 
                options]}]];

ellipticalhyperboloidalpha[u_] := ellipse[1, 2][
        u]
ellipticalhyperboloidbeta[
        u_] := ellipse[1, 2]'[u] + {0, 0, 3}

animate[ellipticalhyperboloidalpha, ellipticalhyperboloidbeta, 0, 
      2  Pi, -1.5, 1.5, 0.01]

pluckeralpha[n_][theta_] := {0, 0, 
        Sin[n theta]}
pluckerbeta[theta_] := {Cos[theta], Sin[theta], 0}

animate[pluckeralpha[4], pluckerbeta, 0, 2  Pi, 0, Sqrt[2], 0.01, 
      PlotPoints -> {20, 50}  ]

moebiusstripalpha[u_] := {Cos[u], Sin[u], 0}
moebiusstripbeta[a_][u_] := 
      a {Cos[u/2] Cos[u],  Cos[u/2] Sin[u], Sin[u/2]}

animate[moebiusstripalpha, moebiusstripbeta[1], 0, 
      2  Pi, - .3,  .3,  .01]

Clear[tandev, helix]
tandev[curve_][u_] :=  
      D[curve[u], u]/
        Sqrt[D[curve[u], u]  .  D[curve[u], u]]
helix[a_, b_][t_] := {a Cos[t], a Sin[t], b t}

animate[helix[1, 0.4], tandev[helix[1, 0.4]], 0, 4  Pi, -2, 2, 
      0.01, PlotPoints -> {40, 10}]

viviani[a_][t_] := a {1 + Cos[t], Sin[t], 2  Sin[t/2]}

animate[viviani[1], tandev[viviani[1]], -2 Pi, 2  Pi, -1, 1, 
      0.01, PlotPoints -> {40, 10}]

rightconoidalpha[u_] := {0, 0, 2 Sin[u]}
rightconoidbeta[u_] := {Cos[u], Sin[u], 0}

animate[rightconoidalpha, rightconoidbeta, -Pi, Pi, -2, 2, 
      0.01, ViewPoint -> {2.257, -1.461, 2.054}, 
      PlotPoints -> {40, 20}]

Die Schmiegtorse

Für eine Kurve c(t)=f∘p(t) auf der Fläche f mit c'(t)≠0 und ein an f tangentiales Vektorfeld längs c(t), für welches II(c'(t),Y(t))=0 gilt und c'(t),Y(t) linear unabhängig sind, heißt die Fläche (s,t) ⟶ c(t) + s Y(t) Schmiegtorse an f.

c[surface_, param_][t_] := surface[param[t] // Evaluate]

Für unser tangentiales Vektorfeld wählen wir Y(t)=(∂_u) f(p(t)).

Y[surface_, param_][
        t_] := (D[surface[u, v], u] // Evaluate) /. 
          u -> List[param[t]][[1]] /. 
        v -> List[param[t]][[2]]

sphaere[u_, v_] := {Cos[u] Cos[v], Cos[u] Sin[v],  
        Sin[u]}

ParametricPlot3D[
        sphaere[u, v] // Evaluate, {u, -Pi, Pi}, {v, -Pi, Pi}, 
        Boxed -> False, Axes -> False];

p[a_][t_] := Sequence[a, t/Cos[a]]

animate[c[sphaere, p[-1]], 
      Y[sphaere, p[-1]], -Pi*Cos[-1], Pi*Cos[-1], -1, 
      1,  .01]

monkeysaddle[u_, v_] := {u, v, u^3 - 3  u v^2}

ParametricPlot3D[
        monkeysaddle[u, v] // Evaluate, {u, -1.5, 1.5}, {v, -1.5, 
          1.5}, ViewPoint -> {1, 3, 1},  AspectRatio -> 1.2, 
        Boxed -> False, Axes -> None];

r[t_] := Sequence[t, t]

animate[c[monkeysaddle, r], Y[monkeysaddle, r], -2, 2, -1, 
      1,  .01, ViewPoint -> {1, 3, 1}, 
      AspectRatio -> 1.2]

Dies ist eine Torse, denn mit

cstrich[t_] := 
      D[c[monkeysaddle, r][u], u] /. u -> t

cstrich[t]

LY[t_] := D[
            Cross[D[monkeysaddle[u, v], u], D[monkeysaddle[u, v], v]], u] /. 
          u -> List[r[t]][[1]] /. 
        v -> List[r[t]][[2]]

LY[t]

ergibt sich für die 2. Fundamentalform von c' und Y:

Dot[cstrich[t], LY[t]]