Uvedený jazzový štandard som sa učil hrať na gitare v rámci výuky hry na gitare ako samouk. Chcel som zistiť a vedieť aké to je naučiť sa celý jazzový štandard. Tento jazzový štandard je z knihy Ballads for Jazz Guitar od Antonia Ongarella.
Hudobná ukážka v mojom podaní: (Harold Arlen - Over the Rainbow)
Uvedený jazzový štandard som sa učil hrať na gitare v rámci výuky hry na gitare v Prahe v roku 2015. Poskytuje vhodné jazzové a bluesové akordy, ktoré sú veľmi dobre široko uplatniteľné.
Uvedený jazzový štandard som sa učil hrať na gitare v rámci výuky hry na gitare v Prahe v roku 2015. Poskytuje vhodné jazzové a bluesové akordy, ktoré sú veľmi dobre široko uplatniteľné.
Isaac Newton ako "objaviteľ" kalkulu (diferenciálneho a integrálneho počtu), ak sa to tak dá nazvať, trpel chorobným strachom z kritiky. Takýto strach často sprevádzajú úzkosti a pocity menejcennosti. Aj preto väčšinu svojich prác nepublikoval, vrátane kalkulu. Až astronóm Edmund Halley ho presvedčil, aby pripravil k vydaniu niektoré časti o zákonoch pohybu a gravitácie. Jeho dielo Matematické základy prírodovedy navždy zmenili pohľad na prírodné vedy. Gottfried Wilhelm Leibniz objavil a vydal kalkulus o niečo málo neskôr ako Newton, čo mu mnohí vytýkali, že to od neho prebral. Newton mu niektoré zápisky poslal dobrovoľne, na jeho požiadanie. Newtonové pojatie kalkulu sa odlišovalo od Leibnizovho hlavne zápisom. Newtonová verzia nebola dobre zrozumiteľná, Leibniz používal geometrický princíp, jeho metóda bola prirodzenejšia. Takže Newtonová symbolika sa používa dodnes skôr vo fyzike a Leibnizova v matematike (aj keď sa prelínajú samozrejme). Dnes považujeme obidvoch za otcov kalkulu. Ale treba podotknúť, že samotné zárodky kalkulu, jeho metódy, a vôbec myšlienka ako taká už bola známa niektorím vedcom už dávnejšie. Bolo to niečo podobné ako s Einsteinovou teóriou relativity. Tieto teórie nevznikali zo dňa na deň, boli výsledkom mnohých vedcov po mnohé stáročia.
Diferenciálnym počtom už ako z názvu vyplýva je možné počítať nejaké diferencie, zmeny. Teda diferenciálnym počtom je možné analyzovať zmeny objektu, jeho pohyb. Ale medzi pohybom a zmenou musí existovať vzťah. A tento vzťah hľadáme práve diferenciálnym počtom. Čiže snažíme sa nájsť mieru zmeny nejakej meniacej sa veličiny, objektu. A práve na to slúži derivovanie. Smer pohybu daného objektu musí byť popísaný vzorcom. Derivovaním tohto vzorca sa vytvorí nový vzorec, ktorý už udáva hľadanú mieru zmeny.
Typickým príkladom je klasický príklad z fyziky, kde máme auto idúce po ceste. Premenná s bude označovať dráhu auta, ktorá sa mení v závislosti na čase t podľa vzorca:.png)
v, čiže miera zmeny polohy, v ľubovoľnom čase t daná vzorcom:
.png)
.png)
.png)
f je rastúca, keï jej derivácia nadobúda kladné hodnoty a klesajúca, keď derivácia nadobúda záporné hodnoty. Bod, v ktorom má funkcia f maximum je v bode, kde je hodnota derivácie nulová. Teda z derivácie je možné vyčítať niektoré informácie o priebehu pôvodnej funkcie.
.png)
a..png)
a. Toto číslo dostaneme tak, že spočítame limitu pre x idúce do a. Prečo počítame toto a prečo takto sa dozvieme neskôr. Zatiaľ vypočítame príklad podľa vzťahov. Takže dostaneme niečo také:.png)
.png)
a a dosadením ľubovoľného čísla v tomto bode dostaneme hodnotu zderivovanej funkcie f(x).
Program vyzerá nasledovne. Bol použitý programovací jazyk C s hlavičkovými súbormi:
#include <stdio .h="">
#include<stdlib .h="">
#include <math .h="">
</math></stdlib></stdio></pre>
Zadefinujeme si funkciu <code><font size="3">f</font></code> s jedným vstupným parametrom typu <code><font size="3">float</font></code>, ktorý vráti hodnotu funkcie typu <code><font size="3">float</font></code> v tomto bode:
<pre>float f(float x)
{
return x*x*x;
}
a:
float PrvaDerivacia(float bod)
{
float xt = bod;
float h = 0.01 * (1 + abs(xt));
bod = xt + h;
float fp = f(bod);
bod = xt - h;
float fm = f(bod);
bod = xt;
return (fp - fm)/2/h;
}
main, ktorá len zavolá funkciu prvaDerivacia a vypíše výsledok na obrazovku:
void main(void)
{
printf("%f", PrvaDerivacia(2));
system("pause");
}
12.000895, čo je približne 12. A naozaj. Funkcia x^3 v bode 2 je 8 a jej derivácia 3x^2 v bode 2 je 12. Teda naozaj nami naprogramovaná funkcia derivuje.
Newton a Leibniz mali za úlohu vyriešiť ako stanoviť "rýchlosť" zmeny funkcie, teda pomer zmeny y = f(x) k zmene x. V grafickom znázornení, na obrázku nižšie, to znamená, nájsť v danom bode x sklon krivky, ktorý je daný veľkosťou uhlu medzi dotyčnicou ku krivke v danom bode (P, Q) a osou x. V číselnom vyjadrení sa veľkosť uhlu vyjadruje ako smernica dotyčnice k danej krivke alebo aj tangens uhla. Táto veľkosť smernice nie je konštantná, závisí od charakteru krivky. Smernica dotyčnice ku krivke závisí od hodnoty x a táto hodnota závisí od y. Čiže hodnoty smerníc definujú našu krivku.
x rastie nie len hodnota funkcie y, ale aj smernica, teda uhol. Nebudeme počítať priamo uhol, ale len pomer sklonu medzi bodmi P a Q, teda smernicu úsečky spájajúcu bod P a Q. Výsledkom bude len pomerné číslo. Takže pri danej hodnote x je výška krivky daná výrazom x^2. Ako spočítame smernicu pre danú hodnotu x ? Čiže ako spočítame v trojuholníku na obrázku uhol medzi osou x a úsečkou PQ ? Myšlienka bola nasledujúca. Pozrieme sa na bod Q, ktorého súradnica je x + h. Výška bodu P je x^2 a výška bodu Q je (x + h)^2. Od bodu P do bodu Q sa krivka ohýba smerom hore. Nemôžeme počítať smernicu v takomto rozpoložení, pretože body P a Q sú od seba prive¾mi vzdialené. Sú od seba vzdialené natoľko, že úsečka PQ nesplýva s krivkou (je medzi nimi medzera). Musíme teda úsečku PQ zmenšiť na menšie úsečky, aby tzv. (lepšie) aproximovala danú krivku. Vtip spočíva v tom, že pri veľmi malých hodnotách hodnoty h bude platiť, že v bode P sa smernica bude blížiť smernici tejto úsečky. Čiže stačí nám spočítať smernicu v bode P, teda prírastok výšky, toho trojuholníka, vydelíme prírastkom vo vodorovnom smere. Prírastok výšky je daný výrazom:.png)
dy (dy = funkčná hodnota v bode Q - funkčná hodnota v bode P). Takto ho označil aj Leibniz, ovšem Newton bol viac fyzik než matematik a označil ho ako dr, podľa vzorca r = t^2. To preto, pretože Newton používal fyzikálny model podľa ktorého označil r ako vzdialenosť polomeru a t ako čas. Leibnizov model sa používa častejšie, najmä v matematike. Newtonové označenie sa používa z veľkej časti vo fyzike.
Prírastok vo vodorovnom smere je h, pretože rozdiel x + h - x = h. Tento prírastok si označíme ako dx.
Takže smernica úsečky spájajúca bod P a Q je daná pomerom dy ku dx, z čoho dostaneme:.png)
.png)
.png)
PQ. Ale nespočítali sme smernicu krivky v bode P! Teraz sme v podstate len zderivovali funkciu y = x^2, čoho výsledkom je funkcia y = 2x. Ovšem nie 2x, ale 2x + h. Newton a Leibniz považovali túto hodnotu h = 0, čo nebolo celkom správne. Ak sa pozrieme na obrázok tak so zmenšujúcou sa hodnotou h sa bod Q približuje k bodu P. Pre každý prírastok h odpovedá výraz 2x + h, tzn. že pre akýkoľvek najmenší prírastok h platí smernica úsečky PQ, ktorú sme spočítali. Takže, ak zvolíme za x = 5 a budeme postupne zmenšovať krok h z 0.1 na 0.01 až 0.000001 atï, tak dostaneme postupne hodnoty, 10.1, 10.01, až 10.000001 atï. A tu je jasne vidieť, že so zmenšujúcim sa krokom h sa smernica blíži k celej hodnote čísla, v našom prípade hodnote 10. Teda počítame vlastne limitu od x idúcu k 0. V reálnej praxi by to znamenalo dosadiť h = 0. Newton a Leibniz uvažovali priamo h = 0, čo z matematického hľadiska nebolo správne, pretože ak dosadíme do poslednej rovnice h = 0 tak výraz na ľavej strane nebude definovaný, pretože podiel 0/0 v matematike nie je definovaný. Preto bolo potrebné uvažovať limitné prípady. To znamená, že z geometrického h¾adiska sa so zmenšujúcim sa h bod Q približuje bodu P a rozdiel medzi smernicou úsečky PQ a smernicou krivky v bode P postupne mizne, čo znamená, že limitná hodnota smernice úsečky PQ bude presnou hodnotou smernice krivky v bode P! Čiže smernica krivky pre hodnotu x je daná výrazom 2x, čo je limitná hodnota výrazu 2x + h pre h blížiace sa k nule.
Tento nedostatok neskôr odstránil Karl Weierstrass zavedením pojmu limity. 
Situácia sa zmení pridaním ďalšieho rozmeru obrazu - rozmeru håbky. V tomto okamihu už dochádza k simulácii ľudského videnia, avšak stále len k simulácii, napodobovaniu, pretože zostrojiť úplne dokonalý obraz ľudského videnia reálneho sveta nie je doposiaľ možné. Z fyzikálneho hľadiska si môžme predstaviť okolitý svet ako spojitý, analógový a svet elektroniky ako nespojitý, digitálny. Najlepšie to reprezentuje videokamera alebo fotoaparát, ktorým snímame jednotlivé obrázky. Procesom snímania okolitého sveta prostredníctvom objektívu je vždy nejaký prevod obrazu z tohto objektívu (analógový signál) na obrazový formát (digitálny signál). Tento prevod je daný nejakou transformáciou. Doposiaľ žiadny objektív nedokáže zachytiť obraz bezchybne, takže okrem samotnej transformácie obrazu dochádza aj k transformačným, korekčným chybám objektívov. Tieto korekcie, transformácie sú vo všeobecnosti vzťahy, ktoré vyjadrujú spojitosť, väzbu, medzi jednotlivými prvkami. Premietanie v našom prípade je transformácia, ktorá charakterizuje prevod trojrozmerných súradníc objektu do dvojrozmerných súradníc, pričom v takejto reprezentácii, ako už bolo spomínané, dochádza vždy k strate priestorovej informácie. Deskriptívna geometria je jedna z matematických disciplín, ktorá sa zaoberá rôznymi prepismi geometrických scén.
Proces ľudského videnia je založený v konečnom dôsledku na vyhodnotení signálov v mozgu. Preto, čím vernejšie vykreslíme 3D scénu na monitore počítača, tým prirodzenejšie bude schopný mozog spracovať jednotlivé signály. Pri spracovaní videnia v určitej fáze prebieha v mozgu k tzv. stranovému kríženiu obrazu (okrem toho aj k zmenšeniu a dvojitému stranovému otočeniu obrazu) z ľavého a pravého oka. Týmto procesom vnímame okolitý svet priestorovo, vzniká dojem håbky. Takýto priestor nie je možné vytvoriť v mozgu z roviny akéhoko¾vek monitora, takže aj keï prakticky neustále dochádza k stranovému kríženiu obrazu, výsledný obraz bude priestorový len do kvality poskytnutej 3D transformácie.
Poznámka: V súvislosti s procesom videnia mozgom, pozná neurológia určitý stav, kedy vidíme obraz, nejaké predmety, ale nedokážeme ich identifikovať. Teda, na sietnici oka sa premieta obraz z okolitého prostredia, ale napriek tomu náš mozog nedokáže jednotlivé signály spracovať a v dôsledku toho, vlastne nevidíme nič, sme slepí. Takýto stav sprevádzajú pomerne ťažké neurologické ochorenia, ale aj keï nie presne v tomto význame ich občas môže zažiť aj zdravý človek, napr. nieko¾ko sekúnd po prebudení zo spánku, alebo tesne pri zaspávaní a v neposlednom rade aj pri požití omamných a psychotropných látok.
V súradnicovej sústave P, x_1, x_2 je axonometria reprezentovaná súradnicovou sústavou O_a, E_{a}^{x}, E_{a}^{y}, E_{a}^{z}, uhlami \xi, \eta a tzv. axonometrickým trojuholníkom, ktorý tvoria jednotkové vektory e^x, e^y, e^z.
Nech bod A \in E^3 má súradnice A(x^A, y^A, z^A) a jeho pôdorys A_1(x^A, y^A, 0). V axonometrii \phi: E^3 \rightarrow \varepsilon \times \varepsilon[/latex] je obrazom bodov A, A_1 usporiadaná dvojica bodov (A_a, A_{1a}) pre ktorú platí [latex]A_a A_{1a} \parallel z_a. Vzh¾adom na axonometrickú súradnicovú sústavu O_a, E_{a}^{x}, E_{a}^{y}, E_{a}^{z} majú body A_a A_{1a} súradnice A_a(x^A e^x, y^A e^y, z^A e^z), A_{1a}(x^A e^x, y^A e^y, 0).
Výpočet konkrétneho bodu A_a(x_1^A, x_2^A) vzhľadom na súradnicovú sústavu Px_1x_2 bude záležitosťou použitia goniometrických funkcií. Teda, podľa daného obrázku platí:.png)
.png)
.png)
.png)
namespace _3D_Renderer
{
class Projection
{
int[,] transformation = new int[8, 2];
public void Axonometric(int x, int y, int z, int n)
{
transformation[n, 0] = (int)(-x * Math.Cos(-0.7) + y * Math.Cos(0.8) + 800 / 2);
transformation[n, 1] = (int)(-x * Math.Sin(-0.3) - y * Math.Sin(-0.2) + z + 600 / 2);
}
public int[,] Transformation
{
get
{
return transformation;
}
}
}
class Program
{
static void Main(string[] args)
{
int width = 800;
int height = 600;
Canvas canvas = new Canvas(width, height);
Projection projection = new Projection();
Color background = new Color(0, 0, 0);
Color white = new Color(255, 255, 255);
canvas.clearColor(background);
int[,] mVertices = { { 0, 0, 0 }, { 100, 0, 0 }, { 100, 0, 100 }, { 0, 0, 100 }, { 0, 100, 0 }, { 100, 100, 0 }, { 100, 100, 100 }, { 0, 100, 100 } };
int[,] mIndices = {
{ 0, 1, 0, 1, 1, 0, 0, 0 },
{ 1, 0, 1, 0, 0, 1, 0, 0 },
{ 0, 1, 0, 1, 0, 0, 1, 0 },
{ 1, 0, 1, 0, 0, 0, 0, 1 },
{ 1, 0, 0, 0, 0, 1, 0, 1 },
{ 0, 1, 0, 0, 1, 0, 1, 0 },
{ 0, 0, 1, 0, 0, 1, 0, 1 },
{ 0, 0, 0, 1, 1, 0, 0, 0 },
};
for (int n = 0; n < 8; n++)
{
projection.Axonometric(mVertices[n, 0], mVertices[n, 1], mVertices[n, 2], n);
}
for (int i = 0; i < 8; i++)
{
for (int j = i; j < 8; j++)
{
if (mIndices[i, j] == 1)
{
canvas.drawLine(white, projection.Transformation[i, 0], projection.Transformation[i, 1], projection.Transformation[j, 0], projection.Transformation[j, 1]);
}
}
}
canvas.render();
System.Diagnostics.Process.Start("Frame.exe", "frame.ppm");
}
}
}
Pri hľadaní perspektívneho zobrazenia sú určujúce jednotlivé priesečníky priemetne \varepsilon so stenou \nu = xz prakticky vytvárajúci pravouhlý trojhran, a tiež voľba stredu lineárnej perspektívy S(s, -d, v). Podľa obrázku (niektoré nasledujúce symboly nie sú na obrázku označené) reprezentuje v, výšku začiatočného bodu S, úsečky SR (teda táto výška rovnobežná s osou z=x_2) a z hľadiska manipulácie perspektívneho obrazu bude možné týmto parametrom meniť výšku celkového pohľadu výsledného obrazu, teda uhol otočenia okolo osy x. Jedná sa o vzdialenosť od tzv. základnej roviny. V prípade v=0 sa budeme nachádzať priamo v horizonte, na obrázku s označením h. Vzdialenosť s je daná začiatočným bodom S, úsečky SR a osy y, resp. pomyselnej roviny yz a bodu S. Týmto parametrom bude možné meniť šírku celkového pohľadu, teda uhol natočenia okolo osy z. A napokon parameter d je tzv. dištancia a je to veľkosť úsečky SH, teda vzdialenosť bodu S od bodu horizontu H. Týmto parametrom bude možné nastaviť celkovú håbku perspektívy.
Z uvedeného popisu perspektívnej scény potrebujeme vyjadriť parametrické rovnice priamky SR. Tie vyjadríme pre každú zložku nasledujúcim spôsobom:.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
namespace _3D_Renderer
{
class Projection
{
int[,] transformation = new int[8, 2];
public void Perspective(int x, int y, int z, int n)
{
int d = 150;
int s = 200;
int v = -75;
transformation[n, 0] = (int)((d * x + s * y) / (d + y) + 800 / 2);
transformation[n, 1] = (int)((v * y + d * z) / (d + y) + 600 / 2);
}
public int[,] Transformation
{
get
{
return transformation;
}
}
}
class Program
{
static void Main(string[] args)
{
int width = 800;
int height = 600;
Canvas canvas = new Canvas(width, height);
Projection projection = new Projection();
Color background = new Color(0, 0, 0);
Color white = new Color(255, 255, 255);
canvas.clearColor(background);
int[,] mVertices = { { 0, 0, 0 }, { 100, 0, 0 }, { 100, 0, 100 }, { 0, 0, 100 }, { 0, 100, 0 }, { 100, 100, 0 }, { 100, 100, 100 }, { 0, 100, 100 } };
int[,] mIndices = {
{ 0, 1, 0, 1, 1, 0, 0, 0 },
{ 1, 0, 1, 0, 0, 1, 0, 0 },
{ 0, 1, 0, 1, 0, 0, 1, 0 },
{ 1, 0, 1, 0, 0, 0, 0, 1 },
{ 1, 0, 0, 0, 0, 1, 0, 1 },
{ 0, 1, 0, 0, 1, 0, 1, 0 },
{ 0, 0, 1, 0, 0, 1, 0, 1 },
{ 0, 0, 0, 1, 1, 0, 0, 0 },
};
for (int n = 0; n < 8; n++)
{
projection.Perspective(mVertices[n, 0], mVertices[n, 1], mVertices[n, 2], n);
}
for (int i = 0; i < 8; i++)
{
for (int j = i; j < 8; j++)
{
if (mIndices[i, j] == 1)
{
canvas.drawLine(white, projection.Transformation[i, 0], projection.Transformation[i, 1], projection.Transformation[j, 0], projection.Transformation[j, 1]);
}
}
}
canvas.render();
System.Diagnostics.Process.Start("Frame.exe", "frame.ppm");
}
}
}
Perspective(), predstavujú už spomínané perspektívne parametre, pričom tieto parametre sa uplatòujú po korekcii šírky a výšky obrazu, takže z toho dôvodu sa obraz nachádza v štvrtom kvadrante celkového obrazu. Ak chceme zobraziť pohľad smerujúci zhora na daný objekt, tak parameter v by mal mať zápornú hodnotu, pretože začiatok súradnicovej sústavy (0,0) je v ľavom hornom rohu obrazu a keï chceme posunúť bod S smerom kolmo nahor, tak potrebujeme odpočítať určitú hodnotu od obrazovej osy y.
Výsledný obrázok perspektívneho zobrazenia kocky pomocou jedného úbežníka je na nasledujúcom obrázku:
Uvedené spôsoby poukázali na niektoré najčastejšie typy premietaní. Vykresľovanie doposiaľ prebiehalo spôsobom známym z OpenGL/DirectX, kedy len pomocou bodu a úsečky vykresľujeme komplexné objekty. Grafické priemyselné štandardy pracujú v režime vykresľovania scény v reálnom čase, to znamená, že akékoľvek grafické objekty sú na priemetni prekresľované v pravidelných časových intervaloch a navyše takýto spôsob vykresľovania úzko súvisí s hardwarovými vymoženosťami grafickej karty. V celom seriály ako aj u uvedenom prípade bol použitý spôsob vykresľovania objektov z grafických priemyselných štandardov, avšak vykresľovanie scény bolo realizované jednorazovym prepisom prostredníctvom zaznamenanych bodov z platna do obrazového suboru typu PPM. Prakticky to znamenalo to, že sme pouzili vektorovy sposob zapisu objektov, a tento zapis sme priamo aplikovali na priemetnu v povodnom stave, ktory sme uz len jednoducho ulozili do uz spominaneho obrazového suboru. Každe vykreslovanie grafických objektov urcitym systemom sa nazyva renderovanie, avšak v povodnom vyzname tohto oznacenia sa jedna o proces, ktory vedie k fotorealistickému zobrazovaniu geometrických objektov.
V nasledujucich castiach serialu pojde o tzv. renderovanie v klasickom vyzname, to znamena, proces tvorby obrazu z 2D/3D modelov pouzitim textur, osvetlovacich modelov a algoritmami tienovania. Jedna sa o systém znamy z integrovanych renderovacich nastrojov od spolocnosti Autodesk, ktora vydava svoje jednotlive produkty ako napr. 3D Studio MAX, Maya, alebo niektore verzie AutoCADu.
V zásade je jedno, či sa bude jednať o reprezentáciu 2D alebo 3D objektov. Odlišnost v zápise je len v počte súradníc, aj keï reprezentácia v 3D je z hľadiska ïalšieho spracovania zložitejšia. Samotná reprezentácia v podstate vychádza z možností zobrazovania grafickej karty počítača. Pomocou grafickej karty sme schopný vykresľovať len body a úsečky, pričom grafickým procesorom je podporované vykresľovanie trojuholníkov. Práve tento trojuholník sa javí z hľadiska reprezentácie ako efektívny, pretože existujú algoritmy, ktoré popisujú jeho vyplňovanie, je možné tiež veľmi efektívne optimalizovať výpočty priesečníkov lúčov s trojuholníkmi. Túto skutočnosť používajú rôzne vykresľovacie (renderovacie) techniky.
Takúto sieť trojuholníkov je možné vidieť napr. na jednoduchom teréne. Intuitívne by nás napadlo vyskladať takúto sieť tak, že zadáme súradnice každého bodu a nejakým spôsobom pospájame jednotlivé body hranami. Ako bolo spomenuté, ideálne je pospájať tieto body ako vrcholy trojuholníka, kde každý trojuholník bude obsahovať teda tri vrcholy (vertexy) a tri hrany (edges).
X alebo spojenie, kde z jedného vrcholu pôjde hrana do všetkých ostatných. Práve na toto odlíšenie potrebujeme ešte ïalší zoznam, ktorý bude popisovať topológiu objektu v podobe hrán, teda ktoré vrcholy budú tvoriť jednotlivé hrany.
Tieto zoznamy sú z matematického hľadiska v podstate množiny obsahujúce informácie o danom objekte. Spolu tieto množiny môžu tvoriť graf, ako matematickú štrukúru, ktorá pozostáva z týchto dvoch množín. Graf je usporiadaná dvojica (V, H), kde V je množina vrcholov a H je množnina hrán, ktorá je navyše ako dvojprvková podmnožina tejto množiny. Dvojprvková preto, pretože obsahuje dvojice vrcholov medzi ktorými sa nachádza hrana.
Napísať a nakresliť takýto graf je možné vo forme diagramu. Máme napr. jeden diagram grafu G_1 = (V_1, H_1), kde V_1 = \left \{ 1,2,3,4,5 \right \} a H_1 = \left \{ \left \{ 1,2 \right \}\left \{ 2,3 \right \}\left \{ 3,4 \right \}\left \{ 4,5 \right \}\left \{ 5,1 \right \} \right \} a diagram grafu G_2 = (V_2, H_2), kde V_2 = \left \{ a,b,c,d,e \right \} a [latex]H_2 = \left \{ \left \{ a,b \right \}\left \{ b,c \right \}\left \{ c,d \right \}\left \{ d,e \right \}\left \{ e,a \right \} \right \}.
.png)
.png)
.png)
.png)
drawLine(), ktorá vykreslí úsečku so zadanými súradnicami.
namespace _2D_Renderer
{
class Program
{
static void Main(string[] args)
{
int width = 800;
int height = 600;
Canvas canvas = new Canvas(width, height);
Color background = new Color(0, 0, 0);
Color white = new Color(255, 255, 255);
canvas.clearColor(background);
canvas.drawLine(white, 300, 200, 400, 300);
canvas.render();
System.Diagnostics.Process.Start("Frame.exe", "frame.ppm");
}
}
}
drawLine(), bol použitý Bresenhamov algoritmus úsečky, ktorých je na internete kvantum. Pre konkrétnosť uvedieme zdrojový kód daného algoritmu:
public void drawLine(Color color, int x1, int y1, int x2, int y2)
{
if ((x1 - x2) > 0)
{
drawLine(color, x2, y2, x1, y1);
return;
}
if (Math.Abs(y2 - y1) > Math.Abs(x2 - x1))
{
bresteepline(color, y1, x1, y2, x2);
return;
}
int x = x1, y = y1, sum = x2 - x1, Dx = 2 * (x2 - x1), Dy = Math.Abs(2 * (y2 - y1));
int deltaDy = ((y2 - y1) > 0) ? 1 : -1;
for (int i = 0; i <= x2-x1; i++)
{
setPixel(x, y, color);
x++;
sum -= Dy;
if (sum < 0)
{
y = y + deltaDy; sum += Dx;
}
}
}
private void bresteepline(Color color, int x3, int y3, int x4, int y4)
{
if ((x3 - x4) > 0)
{
bresteepline(color, x4, y4, x3, y3);
return;
}
int x = x3, y = y3, sum = x4 - x3, Dx = 2 * (x4 - x3), Dy = Math.Abs(2 * (y4 - y3));
int deltaDy = ((y4 - y3) > 0) ? 1 : -1;
for (int i = 0; i <= x4-x3; i++)
{
setPixel(y, x, color);
x++;
sum -= Dy;
if (sum < 0)
{
y = y + deltaDy; sum += Dx;
}
}
}
drawLine() s relevantnými súradnicami vrcholov. Ale ak by sme chceli ponechať súradnice vrcholov a nakresliť jednotlivé úsečky z iných vrcholov museli by sme pomerne pracne prepisovať jednotlivé súradnice vrcholov. Práve pre tento účel bola definovaná matica susednosti a incidencie. Nasledujúci zdrojový kód popisuje ich použitie.
namespace _2D_Renderer
{
class Program
{
static void Main(string[] args)
{
int width = 800;
int height = 600;
Canvas canvas = new Canvas(width, height);
Color background = new Color(0, 0, 0);
Color white = new Color(255, 255, 255);
canvas.clearColor(background);
int[,] mVertices = { { 300, 200 }, { 400, 300 } };
int[,] mIndices = {
{ 0, 1 },
{ 1, 0 }
};
int x1, y1, x2, y2;
for (int i = 0; i < 2; i++)
{
for (int j = i; j < 2; j++)
{
if (mIndices[i, j] == 1)
{
x1 = mVertices[i, 0];
y1 = mVertices[i, 1];
x2 = mVertices[j, 0];
y2 = mVertices[j, 1];
canvas.drawLine(white, x1, y1, x2, y2);
}
}
}
canvas.render();
System.Diagnostics.Process.Start("Frame.exe", "frame.ppm");
}
}
}
namespace _2D_Renderer
{
class Program
{
static void Main(string[] args)
{
int width = 800;
int height = 600;
Canvas canvas = new Canvas(width, height);
Color background = new Color(0, 0, 0);
Color white = new Color(255, 255, 255);
canvas.clearColor(background);
int[,] mVertices = { { 300, 200 }, { 400, 200 }, { 300, 300 }, { 400, 300 } };
int[,] mIndices = {
{ 0, 1, 1, 0 },
{ 1, 0, 0, 1 },
{ 1, 0, 0, 1 },
{ 0, 1, 1, 0 }
};
int x1, y1, x2, y2;
for (int i = 0; i < 4; i++)
{
for (int j = i; j < 4; j++)
{
if (mIndices[i, j] == 1)
{
x1 = mVertices[i, 0];
y1 = mVertices[i, 1];
x2 = mVertices[j, 0];
y2 = mVertices[j, 1];
canvas.drawLine(white, x1, y1, x2, y2);
}
}
}
canvas.render();
System.Diagnostics.Process.Start("Frame.exe", "frame.ppm");
}
}
}
[1, 2] a [2, 1].
Niekedy nie je potrebné zaznamenávať informácie o všetkých hranách objektu, ale len o tých, ktoré sú z hľadiska viditeľnosti prístupné nášmu pohľadu. Ostatné hrany sa ignorujú. To je prípad hraničnej reprezentácie (boundary representation, B-rep). Mohlo by sa zdať, že tento typ rieši určitú problematiku viditeľnosti hrán, avšak je to len zdanie, pretože zadávame len tie hrany, ktoré z hľadiska pohľadu majú byť viditeľné. Teda, popisujeme len plášť objektu (aj keď samotný plášť netvorí plocha, ktorá je nejakým spôsobom definovaná), jeho obrysy. Pri jednoduchých objektoch je táto metóda ešte zvládnuteľná z hľadiska manuálnej selekcie hrán, ale pri zložitejších objektoch to býva časovo náročné.
mesh = GetComponent<MeshFilter>().mesh;
vertices = new Vector3[] { new Vector3(0, 0, 0), new Vector3(0, 0, 1), new Vector3(0, 0, 2), new Vector3(1, 0, 0),
new Vector3(1, 0.5f, 1), new Vector3(1, 0, 2), new Vector3(2, 0, 0), new Vector3(2, 0.5f, 1),
new Vector3(2, 0, 2), new Vector3(3, 0, 0), new Vector3(3, 0, 1), new Vector3(3, 0, 2) };
triangles = new int[] { 0,1,4,3,0,4,1,2,5,4,1,5,3,4,7,6,3,7,4,5,8,7,4,8,6,7,10,9,6,10,7,8,11,10,7,11 };
mesh.Clear();
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh = GetComponent<MeshFilter>().mesh;
vertices = new Vector3[] { new Vector3(0, 0, 0), new Vector3(0, 0, 1), new Vector3(0, 0, 2), new Vector3(1, 0, 0),
new Vector3(1, 0.5f, 1), new Vector3(1, 0, 2), new Vector3(2, 0, 0), new Vector3(2, 0.5f, 1),
new Vector3(2, 0, 2), new Vector3(3, 0, 0), new Vector3(3, 0, 1), new Vector3(3, 0, 2) };
{
int v = 4;
int v0 = v; //ten vertex, na ktory sme klikli mysou
int v1 = v + 1;
int v2 = v - 1;
int v3 = v + 3;
int v4 = v - 3;
int v5 = v + 4;
int v6 = v + 2;
int v7 = v - 4;
int v8 = v - 2;
triangles01 = new int[] { v0, v1, v5, v0, v5, v3, v0, v3, v6, v0, v6, v2, v0, v2, v7, v0, v7, v4, v0, v4, v8, v0, v8, v1 };
}
{
int v = 7;
int v0 = v; //ten vertex, na ktory sme klikli mysou
int v1 = v + 1;
int v2 = v - 1;
int v3 = v + 3;
int v4 = v - 3;
int v5 = v + 4;
int v6 = v + 2;
int v7 = v - 4;
int v8 = v - 2;
triangles02 = new int[] { v0, v1, v5, v0, v5, v3, v0, v3, v6, v0, v6, v2, v0, v2, v7, v0, v7, v4, v0, v4, v8, v0, v8, v1 };
}
mesh.Clear();
mesh.vertices = vertices;
mesh.triangles = triangles01.Concat(triangles02).ToArray();
std::array<Vertex, 12> vertices =
{
Vertex({ XMFLOAT3(0.0f, 0.0f, 0.0f), XMFLOAT4(Colors::Black) }),
Vertex({ XMFLOAT3(0.0f, 0.0f, 1.0f), XMFLOAT4(Colors::Black) }),
Vertex({ XMFLOAT3(0.0f, 0.0f, 2.0f), XMFLOAT4(Colors::Black) }),
Vertex({ XMFLOAT3(1.0f, 0.0f, 0.0f), XMFLOAT4(Colors::Black) }),
Vertex({ XMFLOAT3(1.0f, 0.5f, 1.0f), XMFLOAT4(Colors::Black) }),
Vertex({ XMFLOAT3(1.0f, 0.0f, 2.0f), XMFLOAT4(Colors::Black) }),
Vertex({ XMFLOAT3(2.0f, 0.0f, 0.0f), XMFLOAT4(Colors::Black) }),
Vertex({ XMFLOAT3(2.0f, 0.5f, 1.0f), XMFLOAT4(Colors::Black) }),
Vertex({ XMFLOAT3(2.0f, 0.0f, 2.0f), XMFLOAT4(Colors::Black) }),
Vertex({ XMFLOAT3(3.0f, 0.0f, 0.0f), XMFLOAT4(Colors::Black) }),
Vertex({ XMFLOAT3(3.0f, 0.0f, 1.0f), XMFLOAT4(Colors::Black) }),
Vertex({ XMFLOAT3(3.0f, 0.0f, 2.0f), XMFLOAT4(Colors::Black) })
};
std::array<std::uint16_t, 48> indices;
std::array<std::uint16_t, 24> indices01;
std::array<std::uint16_t, 24> indices02;
{
uint16_t v = 4;
uint16_t v0 = v; //ten vertex, na ktory sme klikli mysou
uint16_t v1 = v + 1;
uint16_t v2 = v - 1;
uint16_t v3 = v + 3;
uint16_t v4 = v - 3;
uint16_t v5 = v + 4;
uint16_t v6 = v + 2;
uint16_t v7 = v - 4;
uint16_t v8 = v - 2;
indices01 =
{
v0, v1, v5, v0, v5, v3, v0, v3, v6, v0, v6, v2, v0, v2, v7, v0, v7, v4, v0, v4, v8, v0, v8, v1
};
}
{
uint16_t v = 7;
uint16_t v0 = v; //ten vertex, na ktory sme klikli mysou
uint16_t v1 = v + 1;
uint16_t v2 = v - 1;
uint16_t v3 = v + 3;
uint16_t v4 = v - 3;
uint16_t v5 = v + 4;
uint16_t v6 = v + 2;
uint16_t v7 = v - 4;
uint16_t v8 = v - 2;
indices02 =
{
v0, v1, v5, v0, v5, v3, v0, v3, v6, v0, v6, v2, v0, v2, v7, v0, v7, v4, v0, v4, v8, v0, v8, v1
};
}
for (int i = 0; i < 24; i++)
{
indices[i] = indices01[i];
}
for (int i = 0; i < 24; i++)
{
indices[24 + i] = indices02[i];
}
const UINT vbByteSize = (UINT)vertices.size() * sizeof(Vertex);
const UINT ibByteSize = (UINT)indices.size() * sizeof(std::uint16_t);
mBoxGeo = std::make_unique<MeshGeometry>();
mBoxGeo->Name = "boxGeo";
ThrowIfFailed(D3DCreateBlob(vbByteSize, &mBoxGeo->VertexBufferCPU));
CopyMemory(mBoxGeo->VertexBufferCPU->GetBufferPointer(), vertices.data(), vbByteSize);
ThrowIfFailed(D3DCreateBlob(ibByteSize, &mBoxGeo->IndexBufferCPU));
CopyMemory(mBoxGeo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);
mBoxGeo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
mCommandList.Get(), vertices.data(), vbByteSize, mBoxGeo->VertexBufferUploader);
mBoxGeo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
mCommandList.Get(), indices.data(), ibByteSize, mBoxGeo->IndexBufferUploader);
mBoxGeo->VertexByteStride = sizeof(Vertex);
mBoxGeo->VertexBufferByteSize = vbByteSize;
mBoxGeo->IndexFormat = DXGI_FORMAT_R16_UINT;
mBoxGeo->IndexBufferByteSize = ibByteSize;
SubmeshGeometry submesh;
submesh.IndexCount = (UINT)indices.size();
submesh.StartIndexLocation = 0;
submesh.BaseVertexLocation = 0;
mBoxGeo->DrawArgs["box"] = submesh;
using UnityEngine;
public class terrainManager : MonoBehaviour {
public static terrainManager instance;
public int terrainWidth, elementWidth;
public terrainElement terrainPrefab;
[HideInInspector]
public Vector3[] coords;
[HideInInspector]
public terrainElement[] terrainElements;
// void OnDrawGizmosSelected()
// {
// foreach(Vector3 vec3 in coords)
// {
// Gizmos.color = Color.red;
// Gizmos.DrawSphere(vec3, .1f);
// }
// }
void Start()
{
instance = this;
CreateCoords();
CreateTerrainElements();
}
private void CreateCoords()
{
coords = new Vector3[(terrainWidth + 1) * (terrainWidth + 1)];
/*
every side needs to be 1 unity longer
*/
for (int i = 0, z = 0; z <= terrainWidth; z++)
{
//outer loop, z-axis
for (int x = 0; x <= terrainWidth; x++, i++)
{
/*
inner loop, x-axis
setting height value based on perlin noise
needs to be optimized low, mid and high frequency noise
*/
float y = Mathf.PerlinNoise((float)x / 20, (float)z / 20) *10;
y = Mathf.Floor(y) / 2;
coords[i] = new Vector3(x, y, z);
}
}
}
private void CreateTerrainElements()
{
int tilesPerSide = terrainWidth / elementWidth;
terrainElements = new terrainElement[tilesPerSide*tilesPerSide];
for (int i = 0, z = 0; z < tilesPerSide; z++)
{
//outer loop, z-axis
for (int x = 0; x < tilesPerSide; x++, i++)
{
terrainElement elementInstance = Instantiate(terrainPrefab, this.transform);
elementInstance.Initialize(x,z);
terrainElements[i] = elementInstance;
}
}
}
}
using UnityEngine;
public class terrainManager : MonoBehaviour {
public static terrainManager instance;
public int terrainWidth, elementWidth;
public terrainElement terrainPrefab;
[HideInInspector]
public Vector3[] coords;
[HideInInspector]
public terrainElement[] terrainElements;
// void OnDrawGizmosSelected()
// {
// foreach(Vector3 vec3 in coords)
// {
// Gizmos.color = Color.red;
// Gizmos.DrawSphere(vec3, .1f);
// }
// }
void Start()
{
instance = this;
CreateCoords();
CreateTerrainElements();
}
private void CreateCoords()
{
coords = new Vector3[(terrainWidth + 1) * (terrainWidth + 1)];
/*
every side needs to be 1 unity longer
*/
for (int i = 0, z = 0; z <= terrainWidth; z++)
{
//outer loop, z-axis
for (int x = 0; x <= terrainWidth; x++, i++)
{
/*
inner loop, x-axis
setting height value based on perlin noise
needs to be optimized low, mid and high frequency noise
*/
float y = Mathf.PerlinNoise((float)x / 20, (float)z / 20) *10;
y = Mathf.Floor(y) / 2;
coords[i] = new Vector3(x, y, z);
}
}
}
private void CreateTerrainElements()
{
int tilesPerSide = terrainWidth / elementWidth;
terrainElements = new terrainElement[tilesPerSide*tilesPerSide];
for (int i = 0, z = 0; z < tilesPerSide; z++)
{
//outer loop, z-axis
for (int x = 0; x < tilesPerSide; x++, i++)
{
terrainElement elementInstance = Instantiate(terrainPrefab, this.transform);
elementInstance.Initialize(x,z);
terrainElements[i] = elementInstance;
}
}
}
}
