Ok, wir haben Ende 2023. Aber immernoch gibt es manchmal Situationen, wo ich weder mit Code noch mit Pseudocode was gut erklären kann. Dann hilft mir oft ein Relikt aus meiner Kindheit namens GFA-Basic. Der Interpreter kümmert sich um die Einrückung und Colorierung während ich tippe. Es gibt kaum Klammern und keine Semicola.
Menschen können das fast vom Blatt lesen, und darum geht es.
Ihr kennt sicher alle diese schönen Kurven, die galant durch eine Reihe von Kontrollpunkten laufen? Nun, gestern hab ich versucht, Emilio zu erklären, wie solche Bezierkurven entstehen:
Durch Interpolation zwischen Punkten, die ihrerseits Interpolationen sind. Vielleicht erkläre ich später noch ein paar Fallstricke zu Anzahl und Reihenfolge dieser Punkte, aber für heute nehmen wir die einfachste Form: Jeder Ankerpunkt, durch den die Kurve läuft, hat zwei spiegelbildliche Kontrollpunkte, durch feine Nadeln zu ihrem Ankerpunkt dargestellt. Deswegen brauchen wir nur einen davon abzuspeichern, der andere leitet sich davon ab.
Der Trick ist nun, dass man die Kurve in Abschnitten zwischen je zwei Ankerpunkten zeichnet. Den ersten Ankerpunkt wird die Kurve in Richtung ausgehender Kontrollpunkt verlassen, den zweiten Ankerpunkt in Richtung eingehender Kontrollpunkt erreichen. Dazu lässt man einen Parameter von 0 nach eins wandern und nutzt ihn insgesamt sechs mal zur Interpolation zwischen je zwei Punkten:
Zunächst errechnet man drei Zwischenpunkte aus vieren, aus denen sich wiederum zwei Zwischenpunkte ergeben, und zwischen diesen liegt der eine gesuchte Punkt, der die eigentliche Kurve zeichnet.
Hier ist der GFA-Basic-Code, um einige zufällige Punkte zu erzeugen und dann eine Bezierkurve durch sie zu zeichnen:
' *** Für Emilio mal eben BezierKurven visualisiert
' *** Remember: We have to calculate 3 levels of interpolation in order to
' *** get those curves going through control points continuously
' ** INITIALISIERUNG
Type Int2 :
x As Short
y As Short
EndType
Local Short maxSegment = 18
Local Short maxContRange = 512
Local Short maxSteps = 120
Global Tang(maxSegment) As Int2
Global Cont(maxSegment) As Int2
Global ext, p As Int2
AutoRedraw = True
OpenW 1, , , 1600, 1280, 0
Global res As Int2 : res.x = _X : res.y = _Y
randomPoints(maxSegment, maxContRange)
DrawBezier(maxSegment, maxSteps)
'Warteschleife
Repeat
DoEvents
Until ext Or InKey$ = #27
CloseW 1
Sub randomPoints(maxSegment&, maxContRange&)
' Generate and draw points
Local T As Int2, C As Int2, segment
For segment = 0 To maxSegment - 1
' tangent points
T.x = Rand(res.x * .8) + res.x * .1
T.y = Rand(res.y * .8) + res.y * .1
Color RGB(128, 128, 128)
Box T.x - 2, T.y - 2, T.x + 3, T.y + 3
' write to array
Tang(segment).x = T.x
Tang(segment).y = T.y
' control points
C.x = Rand(maxContRange) - maxContRange / 2
C.y = Rand(maxContRange) - maxContRange / 2
Color RGB(64, 192, 128)
Box T.x + C.x - 1, T.y + C.y - 1, T.x + C.x + 1, T.y + C.y + 1
Color RGB(128, 144, 255)
Box T.x - C.x - 1, T.y - C.y - 1, T.x - C.x + 1, T.y - C.y + 1
Cont(segment).x = C.x
Cont(segment).y = C.y
Next
Return
Sub DrawBezier(maxSegment&, maxSteps&)
Local Int segment, step, j
Local Float s
Local T0 As Int2, T1 As Int2, C0 As Int2, C1 As Int2
Local R As Int2, G As Int2, B As Int2
Local GR As Int2, RB As Int2
Local Z As Int2, old As Int2
For j = 0 To maxSegment - 1
T0 = Tang(j)
C0 = Cont(j)
' make control point absolute:
C0.x += T0.x : C0.y += T0.y
T1 = Tang((j + 1) % maxSegment)
C1 = Cont((j + 1) % maxSegment)
' mirror control point 1 and make absolute:
C1.x = T1.x - C1.x : C1.y = T1.y - C1.y
For step = 0 To maxSteps
s = step / maxSteps
' Interpolation Level 1:
' grüne Punkte = Tangentialpunkt 0 bis Kontrollpunkt 0
interpol(T0, C0, s, G)
Color RGB(64, 192, 128)
Pset G.x, G.y
' blaue Punkte = Spiegelung von Kontrollpunkt 1 bis Tangentialpunkt 1
interpol(C1, T1, s, B)
Color RGB(128, 144, 255)
Pset B.x, B.y
' rote Punkte = Interpolation zwischen Kontrollpunkten
interpol(C0, C1, s, R)
Color RGB(255, 192, 184)
Pset R.x, R.y
' Interpolation Level 2:
' grün-rote Interpolation
interpol(G, R, s, GR)
' rot-blaue Interpolation
interpol(R, B, s, RB)
' Interpolation Level 3:
' schwarZe Punkte = BeZierkurve
old = Z
interpol(GR, RB, s, Z) ' in Z wird das Ergebnis geschrieben
If step > 0
Color RGB(0, 0, 0)
Line old.x, old.y, Z.x, Z.y
EndIf
Next
Next
Return
Sub interpol(ByRef start As Int2, ByRef end As Int2, s, ByRef p As Int2)
p.x = start.x * (1 - s) + end.x * s
p.y = start.y * (1 - s) + end.y * s
Return
Sub Win_1_MouseWheel(Buttons&, Delta%, MseX%, MseY%)
ext = Buttons && 1
Return
Sub Win_1_ReSize
res.x = _X : res.y = _Y
Win_1.BorderStyle = 0
Return
