In [1]:
from IPython.core.display import HTML
from string import Template
def jsConfig():
src = """
<script>require.config({ baseUrl: 'https://rawgit.com/kompgraf/course-material/master/assets/' });</script>
"""
return HTML(src)
def addScript(script, identifier):
src = Template("""
<div id="${identifier}-container"></div>
<script>require(['${script}'], main => main($$("#${identifier}-container"), '${identifier}'));</script>
""")
return HTML(src.substitute(script = script, identifier = identifier))
jsConfig()
Out[1]:
Az implicit alak a görbét alkotó pontokat egy teszt formájában adja meg, melynek segítségével el lehet dönteni, hogy egy adott pont rajta fekszik-e a görbén. Kétdimenziós esetben az implicit alak felírható a következő formában
$$ f(x, y) = 0, $$mely egyenletet a görbét alkotó pontok elégítik ki. $f$ itt egy tetszőleges valós értékű függvény.
Például, ha az origó középpontú $r$ sugarú kört szeretnénk felírni implicit alakban, akkor
$$ f(x,y) = x^2 + y^2 - r^2. $$A görbék paraméteres megadása egy leképezés valamilyen paramétertartomány és a görbepontok között. A paraméteres alak egy olyan függvény, mely a paraméter értékeihez pozíciókat ad meg a görbén.
Képzeljük el, hogy papíron, ceruzával rajzolunk egy görbét. Ekkor a paraméter tekinthető az időnek, a paraméter tartománya pedig a rajzolás kezdetének és befejeztének. Ekkor a paraméteres alak megadja, hogy egy adott időpillanatban épp hol volt a ceruza:
$$ (x, y) = f(t). $$Vegyük észre, hogy szemben az implicit alakkal, $f$ most egy vektor-értékű függvény.
Paraméteres alakban az origó középpontú $r$ sugarú kört a következő formában írhatjuk le:
$$ f(t) = (\cos t, \sin t) \qquad t \in [0, 2\pi). $$A jegyzet további részeiben a paraméteres alakot fogjuk feltételezni.
Egy görbe megadásához általában szükségünk van úgynevezett kontrollpontokra, melyek a görbe által felvett alakot fogják meghatározni. Ha a görbe egy kontrollponton áthalad, akkor azt mondjuk, hogy interpolálja az adott pontot, míg ellenkező esetben approximálja.
A görbe alakját a kontrollpontok határozzák meg, így a kontrollpontok manipulációjával tudjuk a görbét befolyásolni.
Tegyük fel, hogy adottak a $p_0, p_1, \ldots, p_n$ kontrollpontok. Interpoláció esetén egy olyan $f(t)$ görbét keresünk, mely illeszkedik ezekre a pontokra. Azaz, a $t$ paraméter tartományában vannak olyan $t_0, t_1, \ldots, t_n$ értékek, hogy
$$ \begin{align*} f(t_0) &= p_0\\ f(t_1) &= p_1 \\ &\vdots \\ f(t_n) &= p_n \\ \end{align*} $$Gyakran előforduló probléma, hogy egynél több görbével (görbedarabbal) rendelkezünk, és ezeket szeretnénk valamilyen módon összekapcsolni. Azt, hogy a görbedarabok az összekapcsolás során hogyan találkoznak, a folytonossággal fogjuk jellemezni, és ezt a tulajdonságot a csatlakozási pontban fogjuk vizsgálni.
A $C^0$ matematikai folytonosság egyszerűen azt jelenti, hogy a görbék a végpontjaiknál kapcsolódnak. Azaz, ha van egy $f(t)$ függvénnyel megadott görbénk, melynek paramétertartománya $[t_1, t_2]$ és egy $g(u)$ függvénnyel megadott görbénk, melynek paramétertartománya $[u_1, u_2]$, akkor
$$ f(t_2) = g(u_1). $$
In [6]:
addScript("js/c0-parametric-continuity", "c0-parametric-continuity")
Out[6]:
Ebben az esetben a görbedarabok első deriváltja (a görbéhez húzott érintővektor) megegyezik a csatlakozási pontban. Az előző $f(t)$ és $g(u)$ függvények által leírt görbék esetén tehát
$$ f^\prime(t_2) = g^\prime(u_1). $$Ha a $C^1$ folytonosság nem teljesül, akkor a csatlakozási pontban éles törést figyelhetünk meg.
In [5]:
addScript("js/c1-parametric-continuity", "c1-parametric-continuity")
Out[5]:
$C^2$ matematikai folytonosság esetén a csatlakozási pontban a görbék második deriváltja megegyezik. Azaz
$$ f^{\prime\prime}(t_2) = g^{\prime\prime}(u_1). $$$C^2$ folytonosság hiányában, bár nem lesz törés a csatlakozási pontban, azonban a görbe alakja hirtelen megváltozhat.
In [4]:
addScript("js/c2-parametric-continuity", "c2-parametric-continuity")
Out[4]:
In [3]:
addScript("js/g1-geometric-continuity", "g1-parametric-continuity")
Out[3]:
A matematikai folytonosság szigorúbb, mint a geometriai folytonosság, hiszen az $n$-ed rendű matematikai folytonosság az $n$-edik deriváltak egyenlőségét kívánja meg. Emiatt, ha két görbe $C^n$ matematikai folytonossággal csatlakozik, akkor ez a csatlakozás egyúttal $G^n$ geometriai folytonosságú is.
Ha rendelkezünk a görbe alakját befolyásoló kontrollpontokkal, valamint tudjuk, hogy hanyadfokú polinommal szeretnénk leírni a görbét, felírhatjuk a paraméteres alakot. Azonban ezt háromféle módon is megtehetjük:
A három felírási mód természetesen ekvivalens, azonban mindegyik más előnnyel bír. Nézzünk meg most egy-egy példát!
Legyen a görbét leíró paraméteres függvény $f(t)$, ahol $t \in [0, 1]$! Tegyük fel, hogy adott $4$ kontrollpont, $p_1, p_2, p_3, p_4$ és, hogy harmadfokú görbét szeretnénk képezni. Tegyük fel továbbá, hogy $f(t)$-nek a következő feltételeket kell teljesítenie:
$$ \begin{align*} f(0) &= p_1 \\ f(1) &= p_4 \\ f^{\prime}(0) &= 3(p_2 - p_1) \\ f^{\prime}(1) &= 3(p_4 - p_3) \end{align*} $$Ezzel, azaz a paramétertartomány elejére és végén felvett értékekre tett feltételekkel egyértelműen megadtuk a görbét.
Írjuk fel az előző feltételekkel megadott görbe polinomiális előállítását! Tudjuk, hogy egy olyan harmadfokú polinomot k1resünk, melyre a fenti feltételek teljesülnek. A polinomot írjuk fel először a következő formában:
$$ f(t) = \sum\limits_{i=1}^{n}b_i(t) \cdot p_i, $$ahol $b_i(t)$ az $i$-edik súlyfüggvény. Ezek a súlyfüggvények adják meg, hogy a paramétertartomány egy adott $t$ eleme esetén az eredetileg megadott geometriai feltételek (a $p_i$ kontrollpontok) milyen szerepet játszanak. Tehát $f(t)$ minden $t$ értékre a kontrollpontok egy lineáris kombinációját állítja elő.
Az általános alakja egy $b_i$ súlyfüggvénynek (harmadfokú esetben) a következő:
$$ b_i(t) = a_1 \cdot t^3 + b_1 \cdot t^2 + c_1 \cdot t + d_1 $$Az előző feltételekkel adott görbe esetén a konkrét $b_i$ polinomok a következőek lesznek:
$$ \begin{align*} b_1(t) &= -t^3 + 3t^2 -3t + 1 \\ b_2(t) &= 3t^3 -6t^2 + 3t \\ b_3(t) &= -3t^3 + 3t^2 \\ b_4(t) &= t^3 \end{align*} $$Polinomális alakban felírt görbét könnyedén átírhatunk mátrix alakúra. Dolgozzunk most az előzőleg felírt polinomokkal! Ne felejtsük el, hogy harmadfokú görbével dolgozunk.
Legyen $T(t)$ egy $4\times 1$-es paramétermátrix:
$$ T(t) = \begin{bmatrix} t^3 \\ t^2 \\ t \\ 1 \end{bmatrix} $$Legyen továbbá $M$ az együtthatómátrix, melyet az egyes súlyfüggvényekben szereplő együtthatókból képzünk:
$$ M = \begin{bmatrix} a_1 & b_1 & c_1 & d_1 \\ a_2 & b_2 & c_2 & d_2 \\ a_3 & b_3 & c_3 & d_3 \\ a_4 & b_4 & c_4 & d_4 \\ \end{bmatrix} $$Azaz az előző példa esetében:
$$ M = \begin{bmatrix} -1 & 3 & -3 & 1 \\ 3 & -6 & 3 & 0 \\ -3 & 3 & 0 & 0 \\ 1 & 0 & 0 & 0 \end{bmatrix} $$Végül írjuk fel a geometriai feltételek $G$ mátrixát:
$$ G = \begin{bmatrix} p_1 & p_2 & p_3 & p_4 \end{bmatrix} $$A $G$ mátrix oszlopaiban az egyes kontrollpontok megfelelő koordinátáit találjuk.
Ezután $f(t)$ már felírható
$$ f(t) = GMT(t) $$alakban.
Ha először az $M$ és $T(t)$ mátrixokat szorozzuk össze, akkor az előzőleg felírt bázisfüggvényeket kapjuk Ezeket ezután rendre a megfelelő kontrollponttal beszorozva kapjuk a kontrollpontok lineáris kombinációját.
In [2]:
def styling():
styles = open("../../styles/custom.html", "r").read()
return HTML(styles)
styling()
Out[2]: