Obrázok

java.lang.Object
- java.awt.Image
- - java.awt.image.BufferedImage
  - - Obrázok

Všetky implementované rozhrania:: RenderedImage, WritableRenderedImage, Transparency, Priehľadnosť, Rozmer

Známe priame odvodené triedy:: Obrazok

public class Obrázok
extends BufferedImage
implements Priehľadnosť, Rozmer

Obrázok je rozšírením triedy Javy BufferedImage nielen o funkcionalitu bežne používanú vo svete grafického robota. Obrázok obsahuje komponent grafika, vďaka ktorému môžeme do obrázkov priamo kresliť. Trieda je využiteľná v rôznych situáciách, napríklad pri vypĺňaní plátna, definícii vlastného tvaru robota a podobne. Ponúka nástroje na zrkadlenie, zmenu svetlosti, úpravu na farebný negatív, rozmazanie a tak ďalej.

Upozornenie: Pri úpravách obrázkov (hoci ich vlastnými metódami, napríklad prevráťVodorovne, bledší, negatív, rozmaž a podobne) nikdy nie je spustené automatické prekreslenie! Všetky zmeny vykonané v obrázu sa prejavia až pri jeho najbližšom nakreslení! Následkom je napríklad i to, že ak je obrázok použitý ako vlastný tvar niektorého robota, treba po každej zmene (úprave priehľadnosti, vypĺňaní, kreslení…) zabezpečiť prekreslenie sveta.

Poznámka: Automatické prekresľovanie sveta sa pri úpravách obsahu obrázkov alebo ich vlastností ich vlastnými metódami neaktivuje napríklad i preto, že svet nemá nikdy garantované, či je stanovený obrázok niekde použitý alebo iba pasívne uložený v pamäti…)

Príklad:

Nasledujúci príklad ukazuje možné použitie triedy Obrázok ako vlastného tvaru viacerých robotov znázorňujúcich hodiny (hodinových robotov). Obrázok je prekresľovaný podľa potreby. Takéto použitie je v tomto prípade efektívnejšie, pretože prekresľovanie tvaru je vykonávané len v prípade potreby (v tomto prípade každú minútu) a prekreslený tvar dokáže využiť množstvo robotov naraz.

Príklad obsahuje aj možnosť zobrazenia na celej obrazovke. Tá je pred zrakom Javy zakrytá komentármi označenými dvojitou mriežkou: // ##. Po odstránení všetkých takto označených znakov komentárov (vrátane znakov dvojitej mriežky) bude príklad fungovať v režime celej obrazovky.

import knižnica.*;

import java.util.Calendar;

public class ObrázokAkoTvar extends GRobot
{
    // Spoločná inštancia obrázka, ktorá bude tvoriť vlastný tvar
    // hodinových robotov.
    private final static Obrázok tvarHodín = new Obrázok(50, 50);

    // Atribúty uchovávajúce starý a nový čas. Ak bude zistená zmena,
    // čo bude každú minútu, tak budú hodiny prekreslené.
    private int hodina0 = 0, minúta0 = 0, hodina1 = -1, minúta1 = -1;

    // Nebolo by efektívne overovať hodnoty času niekoľko ráz za sekundu,
    // preto je tu toto počítadlo, ktoré spôsobí, že overenie hodnôt času
    // bude vykonané raz za minútu.
    private int overČasPo = -1;

    // ## private static int zariadenie = 0;
    
    // Súkromná trieda hodín.
    private static class Hodiny extends GRobot
    {
        // Konštruktor, ktorý nastaví všetkým hodinám rovnaké parametre
        // a náhodnú individuálnu rýchlosť.
        private Hodiny()
        {
            zdvihniPero();
            vlastnýTvar(tvarHodín);
            náhodnáPoloha();
            novýCieľ();
            gyroskop(90.0);
            rýchlosť(Svet.náhodnéReálneČíslo(1.5, 3.5), false);
        }

        // Nový cieľ je nastavený na začiatku a potom vždy po dosiahnutí
        // starého cieľa.
        private void novýCieľ()
        {
            Bod štart = poloha();
            náhodnáPoloha();
            Bod cieľ = poloha();
            skočNa(štart);
            cieľ(cieľ);
            kružnica();
        }

        // Reakcia na dosiahnutie cieľa hodinami.
        @Override public void dosiahnutieCieľa()
        {
            novýCieľ();
        }
    }
    
    // Konštruktor hlavného robota. Sú v ňom vykonané potrebné nastavenia
    // a vytvorené hodinové roboty.
    private ObrázokAkoTvar()
    {
        // ## super(Svet.šírkaZariadenia(zariadenie),
        // ## 	Svet.výškaZariadenia(zariadenie));

        // ## Svet.celáObrazovka(zariadenie);
        Svet.nekresli();
        Svet.farbaPozadia(čierna);

        kresliDoObrázka(tvarHodín);
        skry();
        veľkosť(22.0);
        hrúbkaČiary(2.2);
        farba(svetlotyrkysová);

        for (int i = 0; i < 50; ++i)
            new Hodiny();

        Svet.spustiČasovač();
    }

    // Zistenie nových hodnôt času. Metóda používa triedu Javy Calendar.
    private void dajČas()
    {
        Calendar teraz = Calendar.getInstance();
        hodina0 = teraz.get(Calendar.HOUR);
        minúta0 = teraz.get(Calendar.MINUTE);
    }

    // Metóda slúžiaca na nakreslenie tvaru hodín. Kreslenie je vykonané len
    // v prípade, že sa hodnoty času zmenili, pričom hodnoty časových údajov
    // sú overované každú minútu.
    private void nakresliHodiny()
    {
        // Hodnota času je overovaná každú minútu. Predvolená hodnota
        // časovača je 40 ms, to je 25 ráz za sekundu, preto je čas overený
        // každých 1 500 tikov.
        if (0 == ++overČasPo % 1500) dajČas();

        // Kreslenie je vykonané len v prípade, že sa hodnoty času zmenili.
        if (hodina1 != hodina0 || minúta1 != minúta0)
        {
            // Vymazanie starého tvaru hodín.
            tvarHodín.vymaž();

            // Uloženie aktuálnej farby hlavného robota – tá bude použitá
            // na nakreslenie hodín.
            Farba farba = farba();
            domov();

            // Farba pozadia sveta je použitá na vyplnenie tvaru hodín.
            farba(Svet.farbaPozadia());
            kruh();

            // Nakreslenie kružnice uloženou farbou.
            farba(farba);
            kružnica();

            // Nakreslenie štyroch značiek hodín – na 12., 3., 6. a 9. hodine.
            for (int i = 0; i < 4; ++i)
            {
                zdvihniPero();
                dopredu(veľkosť() * 0.8);
                položPero();
                dopredu(veľkosť() * 0.2);
                zdvihniPero();
                dozadu(veľkosť());
                doprava(90);
            }
            položPero();

            // Nakreslenie hodinovej ručičky.
            domov();
            smer(90 - 30 * hodina0 - 0.5 * minúta0);
            dopredu(veľkosť() * 0.5);

            // Nakreslenie minútovej ručičky.
            domov();
            smer(90 - 6 * minúta0);
            dopredu(veľkosť() * 0.9);

            // Synchronizácia hodnôt času – ďalšia zmena nastane o minútu.
            hodina1 = hodina0;
            minúta1 = minúta0;
        }
    }

    // Reakcia na tik časovača. Prekresľuje tvar hodín a svet (obidvoje len
    // ak je to potrebné).
    @Override public void tik()
    {
        nakresliHodiny();
        if (Svet.neboloPrekreslené()) Svet.prekresli();
    }

    // Hlavná metóda.
    public static void main(String... args)
    {
        Svet.použiKonfiguráciu("obrazok-ako-vlastny-tvar.cfg");
        // ## if (Svet.početZariadení() > 1) ++zariadenie;
        new ObrázokAkoTvar();
    }
}

Výsledok:

Hodinové roboty.

Na ploche plátna sa bude pohybovať niekoľko „hodinových robotov.“

Pozri tiež:: Svet.priečinokObrázkov(String)

Prehľad atribútov

Atribúty
Modifikátor a typ	Atribút a opis
`Graphics2D`	`grafika` Grafika obrázka (pre potreby kreslenia do obrázka).
`int`	`sirka` Šírka obrázka.
`int`	`šírka` Šírka obrázka.
`int`	`vyska` Výška obrázka.
`int`	`výška` Výška obrázka.

Atribúty zdedené z triedy java.awt.image.BufferedImage
TYPE_3BYTE_BGR, TYPE_4BYTE_ABGR, TYPE_4BYTE_ABGR_PRE, TYPE_BYTE_BINARY, TYPE_BYTE_GRAY, TYPE_BYTE_INDEXED, TYPE_CUSTOM, TYPE_INT_ARGB, TYPE_INT_ARGB_PRE, TYPE_INT_BGR, TYPE_INT_RGB, TYPE_USHORT_555_RGB, TYPE_USHORT_565_RGB, TYPE_USHORT_GRAY

Atribúty zdedené z triedy java.awt.Image
accelerationPriority, SCALE_AREA_AVERAGING, SCALE_DEFAULT, SCALE_FAST, SCALE_REPLICATE, SCALE_SMOOTH, UndefinedProperty

Atribúty zdedené z rozhrania Priehľadnosť
NEPRIEHLADNA, NEPRIEHĽADNÁ, NEPRIEHLADNE, NEPRIEHĽADNÉ, NEPRIEHLADNY, NEPRIEHĽADNÝ, NEVIDITELNA, NEVIDITEĽNÁ, NEVIDITELNE, NEVIDITEĽNÉ, NEVIDITELNY, NEVIDITEĽNÝ

Atribúty zdedené z rozhrania java.awt.Transparency
BITMASK, OPAQUE, TRANSLUCENT

Prehľad konštruktorov

Konštruktory
Konštruktor a opis
`Obrázok()` Predvolený konštruktor.
`Obrázok(Image obrázok)` Vytvorí nový obrázok podľa zadaného obrázka ako predlohy.
`Obrázok(int šírka, int výška)` Konštruktor, ktorý vytvorí nový prázdny obrázok so zadanými rozmermi (v bodoch).

Prehľad metód

Všetky metódy Statické metódy Inštančné metódy Skutočne definované metódy
Modifikátor a typ	Metóda a opis
`boolean`	`animujeSa()` Zistí, či je práve spustená animácia obrázka.
`void`	`bledsi()` Alias pre `bledší`.
`void`	`bledsi(double faktor)` Alias pre `bledší`.
`void`	`bledší()` Zvýši úroveň svetlosti tohto obrázka.
`void`	`bledší(double faktor)` Zvýši úroveň svetlosti tohto obrázka.
`void`	`ciernobiely()` Alias pre `čiernobiely`.
`void`	`ciernobiely(boolean vyvážiťZložky)` Alias pre `čiernobiely`.
`void`	`ciernobiely(double váhaČervenej, double váhaZelenej, double váhaModrej)` Alias pre `čiernobiely`.
`static Obrazok`	`citaj(Archív archív, String názovPoložky)` Alias pre `čítaj`.
`static Obrazok`	`citaj(String súbor)` Alias pre `čítaj`.
`void`	`čiernobiely()` Upraví tento obrázok do odtieňov šedej s použitím priemerovania farebných zložiek.
`void`	`čiernobiely(boolean vyvážiťZložky)` Upraví tento obrázok do odtieňov šedej s možnosťou určenia predvoleného vyváženia farebných zložiek – podľa modelu ľudského vnímania farieb.
`void`	`čiernobiely(double váhaČervenej, double váhaZelenej, double váhaModrej)` Upraví tento obrázok do odtieňov šedej s možnosťou určenia vlastného vyváženia jednotlivých farebných zložiek.
`static Obrázok`	`čítaj(Archív archív, String názovPoložky)` Prečíta do vnútornej pamäte sveta obrázok zo zadaného archívu a vytvorí z neho nový objekt typu `Obrázok`.
`static Obrázok`	`čítaj(String súbor)` Prečíta do vnútornej pamäte sveta zadaný obrázok zo súboru a vytvorí z neho nový objekt typu `Obrázok`.
`void`	`dalsiaSnimka()` Alias pre `ďalšiaSnímka`.
`void`	`ďalšiaSnímka()` Aktivuje nasledujúcu snímku animácie.
`Vlnenie`	`definovaneVlnenie()` Alias pre `jestvujúceVlnenie`.
`Vlnenie`	`definovanéVlnenie()` Alias pre `jestvujúceVlnenie`.
`boolean`	`doSchranky()` Alias pre `doSchránky`.
`boolean`	`doSchránky()` Vloží obsah tohto obrázka do schránky.
`Vlnenie`	`existujuceVlnenie()` Alias pre `jestvujúceVlnenie`.
`Vlnenie`	`existujúceVlnenie()` Alias pre `jestvujúceVlnenie`.
`Farba`	`farbaBodu(double x, double y)` Zistí farbu bodu (jedného pixela) obrázka na zadaných súradniciach v súradnicovom priestore rámca.
`boolean`	`farbaBodu(double x, double y, Color farba)` Zistí, či sa farba bodu (jedného pixela) obrázka na zadaných súradniciach v súradnicovom priestore rámca zhoduje so zadanou farbou.
`boolean`	`farbaBodu(double x, double y, Farebnosť objekt)` Zistí, či sa farba bodu (jedného pixela) obrázka na zadaných súradniciach v súradnicovom priestore rámca zhoduje s farbou zadaného objektu.
`boolean`	`farbaBodu(double x, double y, int r, int g, int b)` Zistí, či sa farba bodu (jedného pixela) obrázka na zadaných súradniciach v súradnicovom priestore rámca zhoduje s farbou zadanou prostredníctvom farebných zložiek.
`boolean`	`farbaBodu(double x, double y, int r, int g, int b, int a)` Zistí, či sa farba bodu (jedného pixela) obrázka na zadaných súradniciach v súradnicovom priestore rámca zhoduje s farbou zadanou prostredníctvom farebných zložiek a úrovne priehľadnosti.
`Farba`	`farbaBodu(Poloha objekt)` Zistí farbu bodu (jedného pixela) obrázka na súradniciach určených polohou objektu.
`boolean`	`farbaBodu(Poloha objekt, Color farba)` Zistí, či sa farba bodu (jedného pixela) obrázka na súradniciach zadaného objektu v súradnicovom priestore rámca zhoduje so zadanou farbou.
`boolean`	`farbaBodu(Poloha objekt, Farebnosť farebnosť)` Zistí, či sa farba bodu (jedného pixela) obrázka na súradniciach prvého zadaného objektu (v súradnicovom priestore rámca) zhoduje s farbou druhého zadaného objektu.
`boolean`	`farbaBodu(Poloha objekt, int r, int g, int b)` Zistí, či sa farba bodu (jedného pixela) obrázka na súradniciach zadaného objektu (v súradnicovom priestore rámca) zhoduje s farbou zadanou prostredníctvom farebných zložiek a úrovne.
`boolean`	`farbaBodu(Poloha objekt, int r, int g, int b, int a)` Zistí, či sa farba bodu (jedného pixela) obrázka na súradniciach zadaného objektu (v súradnicovom priestore rámca) zhoduje s farbou zadanou prostredníctvom farebných zložiek a úrovne priehľadnosti.
`void`	`farebneTienidlo(Color farba)` Alias pre `farebnéTienidlo`.
`void`	`farebnéTienidlo(Color farba)` Použije na tento obrázok zadané farebné tienidlo.
`void`	`farebnyFilter(Color farba)` Alias pre `farebnýFilter`.
`void`	`farebnýFilter(Color farba)` Použije na tento obrázok zadaný farebný filter.
`void`	`farebnyFilter(Farebnosť objekt)` Alias pre `farebnýFilter`.
`void`	`farebnýFilter(Farebnosť objekt)` Použije na tento obrázok farebný filter podľa farby zadaného objektu.
`void`	`gamaKorekcia(double γ)` Upraví intenzitu farieb obrázka na základe hodnoty parametra gama (γ).
`Graphics2D`	`grafika()` Vráti objekt grafiky obrázka (pre potreby kreslenia do obrázka).
`void`	`jednofarebny(Color farba)` Alias pre `monochromatický`.
`void`	`jednofarebný(Color farba)` Alias pre `monochromatický`.
`void`	`jednofarebny(Farebnosť objekt)` Alias pre `monochromatický`.
`void`	`jednofarebný(Farebnosť objekt)` Alias pre `monochromatický`.
`Vlnenie`	`jestvujuceVlnenie()` Alias pre `jestvujúceVlnenie`.
`Vlnenie`	`jestvujúceVlnenie()` Táto metóda vráti inštanciu vlnenia len v prípade, že jestvuje.
`void`	`kresli(double x, double y, Image obrázok)` Nakreslí do tohto obrázka zadaný obrázok, pričom ho posunie od stredu o zadané súradnice v horizontálnom a vertikálnom smere.
`void`	`kresli(double x, double y, String súbor)` Nakreslí do tohto obrázka obrázok zo zadaného súboru, ktorý bude posunutý od stredu o zadané súradnice v horizontálnom a vertikálnom smere.
`void`	`kresli(Image obrázok)` Nakreslí do stredu tohto obrázka zadaný obrázok.
`void`	`kresli(Poloha objekt, Image obrázok)` Nakreslí do tohto obrázka zadaný obrázok, obrázok bude posunutý o súradnice určené polohou zadaného objektu.
`void`	`kresli(Poloha objekt, String súbor)` Nakreslí do tohto obrázka obrázok zo zadaného súboru, obrázok bude posunutý o súradnice určené polohou zadaného objektu.
`void`	`kresli(Shape tvar)` Táto metóda slúži na kreslenie obrysov zadaného tvaru do obrázka.
`void`	`kresli(Shape tvar, GRobot kreslič)` Táto metóda slúži na kreslenie obrysov zadaného tvaru do obrázka.
`void`	`kresli(String súbor)` Nakreslí do stredu tohto obrázka obrázok zo zadaného súboru.
`GRobot`	`kreslic()` Alias pre `kreslič`.
`void`	`kreslic(GRobot kreslič)` Alias pre `kreslič`.
`GRobot`	`kreslič()` Vráti aktuálneho kresliča obrázka alebo `null`, ak nie je kreslič nastavený.
`void`	`kreslič(GRobot kreslič)` Nastaví „kresliča“ obrázka – grafického robota, ktorý bude slúžiť na alternatívne kreslenie a vypĺňanie tvarov v rámci obrázka.
`void`	`kresliDo(Shape tvar)` Obmedzí kreslenie na tento obrázok na plochu zadaného útvaru (`Shape`).
`void`	`kresliVsade()` Alias pre `kresliVšade`.
`void`	`kresliVšade()` Zruší oblasť na obmedzenie kreslenia na tento obrázok.
`boolean`	`maRozmer(double šírka, double výška)` Alias pre `máRozmer`.
`boolean`	`máRozmer(double šírka, double výška)` Overí zhodu rozmerov obrázka so zadanými rozmermi.
`boolean`	`maRozmer(Rozmer rozmer)` Alias pre `máRozmer`.
`boolean`	`máRozmer(Rozmer rozmer)` Overí zhodu rozmerov obrázka s rozmermi zadaného objektu.
`boolean`	`maSirku(double šírka)` Alias pre `máŠírku`.
`boolean`	`máŠírku(double šírka)` Overí zhodu šírky obrázka so zadanou hodnotou.
`boolean`	`maVlnenie()` Alias pre `máVlnenie`.
`boolean`	`máVlnenie()` Overí, či je definovaná inštancia vlnenia pre tento obrázok.
`boolean`	`maVysku(double výška)` Alias pre `máVýšku`.
`boolean`	`máVýšku(double výška)` Overí zhodu výšky obrázka so zadanou hodnotou.
`double`	`maximalneX()` Alias pre `najväčšieX`.
`double`	`maximálneX()` Alias pre `najväčšieX`.
`double`	`maximalneY()` Alias pre `najväčšieY`.
`double`	`maximálneY()` Alias pre `najväčšieY`.
`double`	`minimalneX()` Alias pre `najmenšieX`.
`double`	`minimálneX()` Alias pre `najmenšieX`.
`double`	`minimalneY()` Alias pre `najmenšieY`.
`double`	`minimálneY()` Alias pre `najmenšieY`.
`void`	`monochromaticky(Color farba)` Alias pre `monochromatický`.
`void`	`monochromatický(Color farba)` Upraví tento obrázok do odtieňov zadanej farby.
`void`	`monochromaticky(Farebnosť objekt)` Alias pre `monochromatický`.
`void`	`monochromatický(Farebnosť objekt)` Upraví tento obrázok do odtieňov farby zadaného objektu.
`double`	`najmensieX()` Alias pre `najmenšieX`.
`double`	`najmensieY()` Alias pre `najmenšieY`.
`double`	`najmenšieX()` Zistí najmenšiu x-ovú súradnicu obrázka.
`double`	`najmenšieY()` Zistí najmenšiu y-ovú súradnicu obrázka.
`double`	`najvacsieX()` Alias pre `najväčšieX`.
`double`	`najvacsieY()` Alias pre `najväčšieY`.
`double`	`najväčšieX()` Zistí najväčšiu x-ovú súradnicu obrázka.
`double`	`najväčšieY()` Zistí najväčšiu y-ovú súradnicu obrázka.
`void`	`negativ()` Alias pre `negatív`.
`void`	`negatív()` Pretvorí tento obrázok na svoj farebný negatív.
`void`	`nekresliDo(Shape tvar)` Vytvára obmedzenie kreslenia na tento obrázok.
`void`	`odstranVlnenie()` Alias pre `odstráňVlnenie`.
`void`	`odstráňVlnenie()` Ukončí vlnenie a úplne odstráni inštanciu vlnenia tohto obrázka z prostredia programovacieho rámca GRobot.
`void`	`odtieneSedej()` Alias pre `čiernobiely`.
`void`	`odtieneSedej(boolean vyvážiťZložky)` Alias pre `čiernobiely`.
`void`	`odtieneSedej(double váhaČervenej, double váhaZelenej, double váhaModrej)` Alias pre `čiernobiely`.
`void`	`odtieneŠedej()` Alias pre `čiernobiely`.
`void`	`odtieneŠedej(boolean vyvážiťZložky)` Alias pre `čiernobiely`.
`void`	`odtieneŠedej(double váhaČervenej, double váhaZelenej, double váhaModrej)` Alias pre `čiernobiely`.
`int`	`opakovaniaAnimacie()` Alias pre `opakovaniaAnimácie`.
`int`	`opakovaniaAnimácie()` Zistí, koľko opakovaní zostáva do ukončenia animácie.
`void`	`opakovaniaAnimacie(int početOpakovaní)` Alias pre `opakovaniaAnimácie`.
`void`	`opakovaniaAnimácie(int početOpakovaní)` Ak má tento obrázok nenulový počet snímok animácie, tak táto metóda nastaví nový počet opakovaní animácie zostávajúci do ukončenia animácie a to bez ohľadu na to, či je animácia spustená alebo nie.
`Farba[]`	`paleta(int početFarieb)` Vyrobí paletu najpoužívanejších farieb vyskytujúcich sa v aktuálnej snímke obrázka so zadaným maximálnym počtom farieb.
`Farba[]`	`paleta(int početFarieb, int hranicaZdravia)` Vyrobí paletu najpoužívanejších farieb vyskytujúcich sa v aktuálnej snímke obrázka so zadaným maximálnym počtom farieb a hranicou zdravia 256.
`int`	`pocetFarieb()` Alias pre `početFarieb`.
`int`	`pocetOpakovani()` Alias pre `početOpakovaní`.
`void`	`pocetOpakovani(int početOpakovaní)` Alias pre `početOpakovaní`.
`int`	`pocetSnimok()` Alias pre `početSnímok`.
`int`	`početFarieb()` Zistí počet farieb použitých v aktuálnej snímke obrázka.
`int`	`početOpakovaní()` Zistí, koľko opakovaní zostáva do ukončenia animácie.
`void`	`početOpakovaní(int početOpakovaní)` Ak má tento obrázok nenulový počet snímok animácie, tak táto metóda nastaví nový počet opakovaní animácie zostávajúci do ukončenia animácie a to bez ohľadu na to, či je animácia spustená alebo nie.
`int`	`početSnímok()` Vráti aktuálny počet snímok animácie uloženej v tomto obrázku.
`boolean`	`porovnaj(Image inýObrázok)` Porovná obsah tejto a zadanej inštancie obrázka.
`static boolean`	`porovnaj(Image obrázok1, Image obrázok2)` Porovná obsahy dvoch zadaných inštancií obrázkov.
`void`	`poslednaSnimka()` Alias pre `poslednáSnímka`.
`void`	`poslednáSnímka()` Aktivuje poslednú snímku animácie.
`void`	`posterizuj()` Posterizuje obrázok podľa predvolenej palety preddefinovaných farieb.
`void`	`posterizuj(boolean difúziaChyby)` Posterizuje obrázok podľa predvolenej palety preddefinovaných farieb a umožňuje zvoliť, či má byť pri tomto procese použitý algoritmus difúzie chyby.
`void`	`posterizuj(boolean difúziaChyby, Color[] paleta)` Posterizuje obrázok podľa palety zadanej vo forme poľa farieb a umožňuje zvoliť, či má byť pri tomto procese použitý algoritmus difúzie chyby.
`void`	`posterizuj(boolean difúziaChyby, Color prváFarba, Color... ostatnéFarby)` Posterizuje obrázok podľa palety zadanej vo forme zoznamu farieb, pričom povinné je zadanie aspoň jednej farby a umožňuje zvoliť, či má byť pri tomto procese použitý algoritmus difúzie chyby.
`void`	`posterizuj(Color[] paleta)` Posterizuje obrázok podľa palety zadanej vo forme poľa farieb.
`void`	`posterizuj(Color prváFarba, Color... ostatnéFarby)` Posterizuje obrázok podľa palety zadanej vo forme zoznamu farieb, pričom povinné je zadanie aspoň jednej farby.
`boolean`	`pouziMasku(BufferedImage maska)` Alias pre `použiMasku`.
`boolean`	`použiMasku(BufferedImage maska)` Použije na tento obrázok masku vyrobenú zo zadaného obrázka.
`static Obrazok`	`precitaj(Archív archív, String názovPoložky)` Alias pre `čítaj`.
`static Obrazok`	`precitaj(String súbor)` Alias pre `čítaj`.
`static Obrázok`	`prečítaj(Archív archív, String názovPoložky)` Alias pre `čítaj`.
`static Obrázok`	`prečítaj(String súbor)` Alias pre `čítaj`.
`void`	`predchadzajucaSnimka()` Alias pre `predchádzajúcaSnímka`.
`void`	`predchádzajúcaSnímka()` Aktivuje predchádzajúcu snímku animácie.
`void`	`prepisBod(double x, double y, Color farba)` Alias pre `prepíšBod`.
`void`	`prepisBod(double x, double y, Farebnosť objekt)` Alias pre `prepíšBod`.
`void`	`prepisBod(double x, double y, int farba)` Alias pre `prepíšBod`.
`void`	`prepisBod(Poloha bod, Color farba)` Alias pre `prepíšBod`.
`void`	`prepisBod(Poloha bod, Farebnosť objekt)` Alias pre `prepíšBod`.
`void`	`prepisBod(Poloha bod, int farba)` Alias pre `prepíšBod`.
`void`	`prepíšBod(double x, double y, Color farba)` Prepíše farebné zložky a zložku priehľadnosti bodu na zadanej pozícii zadanou farbou.
`void`	`prepíšBod(double x, double y, Farebnosť objekt)` Prepíše farebné zložky a zložku priehľadnosti bodu na zadanej pozícii farbou zadaného objektu.
`void`	`prepíšBod(double x, double y, int farba)` Prepíše farebné zložky a zložku priehľadnosti bodu na zadanej pozícii zadanou kombináciou zložiek ARGB zakódovaných v celočíselnej hodnote.
`void`	`prepíšBod(Poloha bod, Color farba)` Prepíše farebné zložky a zložku priehľadnosti na pozícii zadaného bodu zadanou farbou.
`void`	`prepíšBod(Poloha bod, Farebnosť objekt)` Prepíše farebné zložky a zložku priehľadnosti na pozícii zadaného bodu farbou zadaného objektu.
`void`	`prepíšBod(Poloha bod, int farba)` Prepíše farebné zložky a zložku priehľadnosti na pozícii zadaného bodu zadanou kombináciou zložiek ARGB zakódovaných v celočíselnej hodnote.
`void`	`pretoc(double Δx, double Δy)` Alias pre `pretoč`.
`void`	`pretoč(double Δx, double Δy)` Pretočí obsah obrázka o zadaný počet bodov v horizontálnom a/alebo vertikálnom smere.
`void`	`prevratHorizontalne()` Alias pre `prevráťVodorovne`.
`void`	`prevráťHorizontálne()` Prevráti obrázok podľa zvislej osi – pravá časť obrázka sa ocitne vľavo a naopak.
`void`	`prevratVertikalne()` Alias pre `prevráťZvislo`.
`void`	`prevráťVertikálne()` Prevráti obrázok podľa vodorovnej osi – horná časť obrázka sa ocitne dole a naopak.
`void`	`prevratVodorovne()` Alias pre `prevráťVodorovne`.
`void`	`prevráťVodorovne()` Prevráti obrázok podľa zvislej osi – pravá časť obrázka sa ocitne vľavo a naopak.
`void`	`prevratZvislo()` Alias pre `prevráťZvislo`.
`void`	`prevráťZvislo()` Prevráti obrázok podľa vodorovnej osi – horná časť obrázka sa ocitne dole a naopak.
`void`	`pridajSnimku()` Alias pre `pridajSnímku`.
`void`	`pridajSnímku()` Pridá novú snímku na koniec animácie s aktuálnou (naposledy použitou) hodnotou trvania zobrazenia a s aktuálnou grafikou obrázka.
`void`	`pridajSnimku(Image obrázok)` Alias pre `pridajSnímku`.
`void`	`pridajSnímku(Image obrázok)` Pridá novú snímku na koniec animácie s aktuálnou (naposledy použitou) hodnotou trvania zobrazenia a so zadanou grafikou.
`void`	`pridajSnimku(Image obrázok, double trvanie)` Alias pre `pridajSnímku`.
`void`	`pridajSnímku(Image obrázok, double trvanie)` Pridá novú snímku na koniec animácie so zadanou grafikou a so zadanou hodnotou trvania jej zobrazenia.
`void`	`pridajVlnenie()` Pridá alebo zresetuje vlnenie tohto obrázka.
`void`	`pridajVlnenie(boolean ajČasovač)` Pridá alebo zresetuje vlnenie tohto obrázka.
`void`	`pridajVlnenie(int útlm)` Pridá alebo zresetuje vlnenie tohto obrázka.
`void`	`pridajVlnenie(int útlm, boolean ajČasovač)` Pridá alebo zresetuje vlnenie tohto obrázka.
`static String`	`priecinokObrazkov()` Alias pre `priečinokObrázkov`.
`static void`	`priecinokObrazkov(String priečinok)` Alias pre `priečinokObrázkov`.
`static String`	`priečinokObrázkov()` Vráti reťazec s aktuálnym priečinkom, z ktorého sú obrázky prečítané.
`static void`	`priečinokObrázkov(String priečinok)` Ak sú všetky obrázky uložené v spoločnom priečinku, môžeme pre nich touto metódou nastaviť zdrojový priečinok čítania.
`double`	`priehladnost()` Alias pre `priehľadnosť`.
`double`	`priehľadnosť()` Zistí aktuálnu úroveň priehľadnosti tohto obrázka.
`void`	`priehladnost(double priehľadnosť)` Alias pre `priehľadnosť`.
`void`	`priehľadnosť(double priehľadnosť)` Nastaví novú úroveň (ne)priehľadnosti tohto obrázka, pričom jednotlivé body na obrázku môžu mať svoju vlastnú úroveň priehľadnosti.
`void`	`priehladnost(Priehľadnosť objekt)` Alias pre `priehľadnosť`.
`void`	`priehľadnosť(Priehľadnosť objekt)` Skopíruje úroveň (ne)priehľadnosti zo zadaného objektu.
`void`	`prvaSnimka()` Alias pre `prváSnímka`.
`void`	`prváSnímka()` Aktivuje prvú snímku animácie.
`void`	`roluj(double Δx, double Δy)` Posunie obsah obrázka o zadaný počet bodov v horizontálnom a/alebo vertikálnom smere.
`void`	`rozmaz()` Alias pre `rozmaž`.
`void`	`rozmaz(Color pozadie)` Alias pre `rozmaž`.
`void`	`rozmaz(Farebnosť pozadie)` Alias pre `rozmaž`.
`void`	`rozmaz(int opakovanie)` Alias pre `rozmaž`.
`void`	`rozmaz(int opakovanie, Color pozadie)` Alias pre `rozmaž`.
`void`	`rozmaz(int opakovanie, Farebnosť pozadie)` Alias pre `rozmaž`.
`void`	`rozmaz(int opakovanie, int rozsah)` Alias pre `rozmaž`.
`void`	`rozmaz(int opakovanie, int rozsah, Color pozadie)` Alias pre `rozmaž`.
`void`	`rozmaz(int opakovanie, int rozsah, Farebnosť pozadie)` Alias pre `rozmaž`.
`void`	`rozmaz(int bgr, int bgg, int bgb)` Alias pre `rozmaž`.
`void`	`rozmaz(int opakovanie, int bgr, int bgg, int bgb)` Alias pre `rozmaž`.
`void`	`rozmaz(int opakovanie, int rozsah, int bgr, int bgg, int bgb)` Alias pre `rozmaž`.
`void`	`rozmaž()` Rozmaže grafiku obrázka.
`void`	`rozmaž(Color pozadie)` Rozmaže grafiku obrázka.
`void`	`rozmaž(Farebnosť pozadie)` Rozmaže grafiku obrázka.
`void`	`rozmaž(int opakovanie)` Rozmaže grafiku obrázka.
`void`	`rozmaž(int opakovanie, Color pozadie)` Rozmaže grafiku obrázka.
`void`	`rozmaž(int opakovanie, Farebnosť pozadie)` Rozmaže grafiku obrázka.
`void`	`rozmaž(int opakovanie, int rozsah)` Rozmaže grafiku obrázka.
`void`	`rozmaž(int opakovanie, int rozsah, Color pozadie)` Rozmaže grafiku obrázka.
`void`	`rozmaž(int opakovanie, int rozsah, Farebnosť pozadie)` Rozmaže grafiku obrázka.
`void`	`rozmaž(int bgr, int bgg, int bgb)` Rozmaže grafiku obrázka.
`void`	`rozmaž(int opakovanie, int bgr, int bgg, int bgb)` Rozmaže grafiku obrázka.
`void`	`rozmaž(int opakovanie, int rozsah, int bgr, int bgg, int bgb)` Rozmaže grafiku obrázka.
`Rozmer`	`rozmery()` Vráti rozmery obrázka v implementácii rozhrania `Rozmer`.
`void`	`rozmery(Rozmer rozmer)` Implementácia metódy rozhrania `Rozmer` určenej na nastavenie obidvoch rozmerov obrázka.
`double`	`rychlost()` Alias pre `rýchlosť`.
`double`	`rýchlosť()` Vráti aktuálnu rýchlosť prehrávania animácie (bez ohľadu na to, či je práve animácia spustená alebo nie).
`void`	`rychlost(double nováRýchlosť)` Alias pre `rýchlosť`.
`void`	`rýchlosť(double nováRýchlosť)` Upraví rýchlosť prehrávania animácie (bez ohľadu na to, či je práve animácia spustená alebo nie).
`double`	`rychlostAnimacie()` Alias pre `rýchlosťAnimácie`.
`double`	`rýchlosťAnimácie()` Vráti aktuálnu rýchlosť prehrávania animácie (bez ohľadu na to, či je práve animácia spustená alebo nie).
`void`	`rychlostAnimacie(double nováRýchlosť)` Alias pre `rýchlosťAnimácie`.
`void`	`rýchlosťAnimácie(double nováRýchlosť)` Upraví rýchlosť prehrávania animácie (bez ohľadu na to, či je práve animácia spustená alebo nie).
`double`	`sirka()` Alias pre `šírka`.
`void`	`sirka(double šírka)` Alias pre `šírka`.
`int`	`snimka()` Alias pre `snímka`.
`int`	`snímka()` Vráti index aktívnej snímky animácie.
`void`	`snimka(int indexSnímky)` Alias pre `snímka`.
`void`	`snímka(int indexSnímky)` Aktivuje zadanú snímku animácie.
`void`	`spusti()` Spustí animáciu s nekonečným počtom opakovaní v naposledy použitom smere prehrávania.
`void`	`spusti(int početOpakovaní)` Spustí animáciu so zadaným počtom opakovaní v naposledy použitom smere prehrávania.
`void`	`spustiAnimaciu()` Alias pre `spustiAnimáciu`.
`void`	`spustiAnimáciu()` Spustí animáciu s nekonečným počtom opakovaní v naposledy použitom smere prehrávania.
`void`	`spustiAnimaciu(int početOpakovaní)` Alias pre `spustiAnimáciu`.
`void`	`spustiAnimáciu(int početOpakovaní)` Spustí animáciu so zadaným počtom opakovaní v naposledy použitom smere prehrávania.
`void`	`spustiAnimaciuDopredu()` Alias pre `spustiAnimáciuDopredu`.
`void`	`spustiAnimáciuDopredu()` Spustí animáciu dopredu s nekonečným počtom opakovaní.
`void`	`spustiAnimaciuDopredu(int početOpakovaní)` Alias pre `spustiAnimáciuDopredu`.
`void`	`spustiAnimáciuDopredu(int početOpakovaní)` Spustí animáciu dopredu so zadaným počtom opakovaní.
`void`	`spustiAnimaciuPospiatku()` Alias pre `spustiAnimáciuPospiatku`.
`void`	`spustiAnimáciuPospiatku()` Spustí animáciu pospiatku s nekonečným počtom opakovaní.
`void`	`spustiAnimaciuPospiatku(int početOpakovaní)` Alias pre `spustiAnimáciuPospiatku`.
`void`	`spustiAnimáciuPospiatku(int početOpakovaní)` Spustí animáciu pospiatku so zadaným počtom opakovaní.
`void`	`spustiDopredu()` Spustí animáciu dopredu s nekonečným počtom opakovaní.
`void`	`spustiDopredu(int početOpakovaní)` Spustí animáciu dopredu so zadaným počtom opakovaní.
`void`	`spustiPospiatku()` Spustí animáciu pospiatku s nekonečným počtom opakovaní.
`void`	`spustiPospiatku(int početOpakovaní)` Spustí animáciu pospiatku so zadaným počtom opakovaní.
`void`	`svetlejsi()` Alias pre `bledší`.
`void`	`svetlejsi(double faktor)` Alias pre `bledší`.
`void`	`svetlejší()` Alias pre `bledší`.
`void`	`svetlejší(double faktor)` Alias pre `bledší`.
`void`	`svetlo(Obrázok osvetlenie)` Táto metóda použije na tento obrázok zadanú svetelnú masku.
`void`	`svetlo(Obrázok grafika, Obrázok osvetlenie)` Táto metóda použije na obrázok zadaný v prvom parametri (`grafika`) svetelnú masku zadanú v druhom parametri (`osvetlenie`) a výsledok zlúči do tejto (`this`) inštancie obrázka.
`double`	`šírka()` Vráti šírku obrázka.
`void`	`šírka(double šírka)` Implementácia metódy rozhrania `Rozmer` určenej na nastavenie šírky obrázka.
`void`	`tmavsi()` Alias pre `tmavší`.
`void`	`tmavsi(double faktor)` Alias pre `tmavší`.
`void`	`tmavší()` Zníži úroveň svetlosti tohto obrázka.
`void`	`tmavší(double faktor)` Zníži úroveň svetlosti tohto obrázka.
`double`	`trvanie()` Zistí hodnotu trvania zobrazenia aktívnej snímky.
`void`	`trvanie(double trvanie)` Nastaví novú hodnotu trvania aktívnej snímky.
`double`	`trvanie(int indexSnímky)` Zistí hodnotu trvania zobrazenia zadanej snímky.
`void`	`trvanie(int indexSnímky, double trvanie)` Nastaví novú hodnotu trvania zadanej snímky.
`double`	`trvanieZobrazeniaSnimky()` Alias pre `trvanieZobrazeniaSnímky`.
`double`	`trvanieZobrazeniaSnímky()` Zistí hodnotu trvania zobrazenia aktívnej snímky.
`void`	`trvanieZobrazeniaSnimky(double trvanie)` Alias pre `trvanieZobrazeniaSnímky`.
`void`	`trvanieZobrazeniaSnímky(double trvanie)` Nastaví novú hodnotu trvania aktívnej snímky.
`double`	`trvanieZobrazeniaSnimky(int indexSnímky)` Alias pre `trvanieZobrazeniaSnímky`.
`double`	`trvanieZobrazeniaSnímky(int indexSnímky)` Zistí hodnotu trvania zobrazenia zadanej snímky.
`void`	`trvanieZobrazeniaSnimky(int indexSnímky, double trvanie)` Alias pre `trvanieZobrazeniaSnímky`.
`void`	`trvanieZobrazeniaSnímky(int indexSnímky, double trvanie)` Nastaví novú hodnotu trvania zadanej snímky.
`apacheAntZIP.ZipEntry[]`	`uloz(Archív archív, String názovPoložky)` Alias pre `ulož`.
`void`	`uloz(String súbor)` Alias pre `ulož`.
`void`	`uloz(String súbor, boolean prepísať)` Alias pre `ulož`.
`apacheAntZIP.ZipEntry[]`	`ulož(Archív archív, String názovPoložky)` Uloží obsah obrázka do archívu ako položku so zadaným názvom.
`void`	`ulož(String súbor)` Uloží obrázok do súboru.
`void`	`ulož(String súbor, boolean prepísať)` Uloží obsah obrázka do súboru.
`void`	`upravJasKontrast(double jas, double kontrast)` Upraví parametre jasu a kontrastu celého obrázka.
`void`	`upravPriehladnost(double zmena)` Alias pre `upravPriehľadnosť`.
`void`	`upravPriehľadnosť(double zmena)` Upraví úroveň (ne)priehľadnosti obráza.
`Vlnenie`	`vlnenie()` Vráti inštanciu vlnenia pre tento obrázok, aby bolo možné s vlnením ďalej pracovať.
`void`	`vlozSnimku(int indexSnímky)` Alias pre `vložSnímku`.
`void`	`vlozSnimku(int indexSnímky, Image obrázok)` Alias pre `vložSnímku`.
`void`	`vlozSnimku(int indexSnímky, Image obrázok, double trvanie)` Alias pre `vložSnímku`.
`void`	`vložSnímku(int indexSnímky)` Vloží novú snímku animácie na zadanú pozíciu s aktuálnou (naposledy použitou) hodnotou trvania zobrazenia a s aktuálnou grafikou obrázka.
`void`	`vložSnímku(int indexSnímky, Image obrázok)` Vloží novú snímku animácie na zadanú pozíciu s aktuálnou (naposledy použitou) hodnotou trvania zobrazenia a so zadanou grafikou.
`void`	`vložSnímku(int indexSnímky, Image obrázok, double trvanie)` Vloží novú snímku animácie na zadanú pozíciu so zadanou grafikou a so zadanou hodnotou trvania jej zobrazenia.
`void`	`vylejFarbu(double x, double y, Color farba)` Vyleje do zadaného bodu do obrázka farbu, ktorá sa odtiaľ rozšíri po okraje tej časti kresby v obrázku, v ktorej sa zadaný bod nachádza.
`void`	`vylejFarbu(double x, double y, Farebnosť objekt)` Vyleje do zadaného bodu do obrázka farbu (určenú objektom), ktorá sa odtiaľ rozšíri po okraje tej časti kresby v obrázku, v ktorej sa zadaný bod nachádza.
`Farba`	`vylejFarbu(double x, double y, int r, int g, int b)` Vyleje do zadaného bodu do obrázka farbu zadanú prostredníctvom farebných zložiek, ktorá sa určeného bodu rozšíri po okraje okolitej kresby.
`Farba`	`vylejFarbu(double x, double y, int r, int g, int b, int a)` Vyleje do zadaného bodu do obrázka farbu zadanú prostredníctvom farebných zložiek a úrovne (ne)priehľadnosti, pričom farba sa z určeného bodu rozšíri k okrajom okolitej kresby.
`void`	`vylejFarbu(GRobot ktorý)` Zadaný robot vyleje na svojej pozícii do obrázka svoju aktuálnu farbu, ktorá sa odtiaľ rozšíri po okraje okolitej kresby.
`void`	`vylejFarbu(Poloha bod, Color farba)` Vyleje do zadaného bodu do obrázka farbu, ktorá sa odtiaľ rozšíri po okraje tej časti kresby v obrázku, v ktorej sa zadaný bod nachádza.
`void`	`vylejFarbu(Poloha bod, Farebnosť objekt)` Vyleje do zadaného bodu do obrázka farbu (určenú objektom), ktorá sa odtiaľ rozšíri po okraje tej časti kresby v obrázku, v ktorej sa zadaný bod nachádza.
`Farba`	`vylejFarbu(Poloha bod, int r, int g, int b)` Vyleje do zadaného bodu do obrázka farbu zadanú prostredníctvom farebných zložiek, ktorá sa určeného bodu rozšíri po okraje okolitej kresby.
`Farba`	`vylejFarbu(Poloha bod, int r, int g, int b, int a)` Vyleje do zadaného bodu do obrázka farbu zadanú prostredníctvom farebných zložiek a úrovne (ne)priehľadnosti, pričom farba sa z určeného bodu rozšíri k okrajom okolitej kresby.
`void`	`vymaz()` Alias pre `vymaž`.
`boolean`	`vymazKresbu(BufferedImage kresba)` Alias pre `vymažKresbu`.
`void`	`vymazSnimku()` Alias pre `vymažSnímku`.
`void`	`vymazSnimku(int indexSnímky)` Alias pre `vymažSnímku`.
`void`	`vymaž()` Vymaže obsah obrázka.
`boolean`	`vymažKresbu(BufferedImage kresba)` Použije na tento obrázok filter vyrobený zo zložky jasu kresby zadaného/predloženého obrázka.
`void`	`vymažSnímku()` Vymaže aktuálnu snímku animácie a aktivuje najbližšiu dostupnú snímku.
`void`	`vymažSnímku(int indexSnímky)` Vymaže zadanú snímku animácie a ak to bola aktívna snímka, tak aktivuje najbližšiu dostupnú snímku.
`void`	`vypln(Color farba)` Alias pre `vyplň`.
`void`	`vyplň(Color farba)` Vyplní celú plochu obrázka zadanou farbou.
`void`	`vypln(Farebnosť objekt)` Alias pre `vyplň`.
`void`	`vyplň(Farebnosť objekt)` Vyplní celú plochu obrázka farbou zadaného objektu.
`void`	`vypln(Image výplň)` Alias pre `vyplň`.
`void`	`vyplň(Image výplň)` Vyplní obrázok zadanou textúrou.
`Farba`	`vypln(int r, int g, int b)` Alias pre `vyplň`.
`Farba`	`vyplň(int r, int g, int b)` Vyplní obrázok farbou zadanou prostredníctvom farebných zložiek.
`Farba`	`vypln(int r, int g, int b, int a)` Alias pre `vyplň`.
`Farba`	`vyplň(int r, int g, int b, int a)` Vyplní obrázok farbou zadanou prostredníctvom farebných zložiek a úrovne (ne)priehľadnosti.
`void`	`vypln(Shape tvar)` Alias pre `vyplň`.
`void`	`vyplň(Shape tvar)` Táto metóda slúži na kreslenie vyplnených tvarov do obrázka.
`void`	`vypln(Shape tvar, GRobot kreslič)` Alias pre `vyplň`.
`void`	`vyplň(Shape tvar, GRobot kreslič)` Táto metóda slúži na kreslenie vyplnených tvarov do obrázka.
`void`	`vypln(Shape tvar, Image výplň)` Alias pre `vypln`.
`void`	`vyplň(Shape tvar, Image výplň)` Vyplní zadaný tvar textúrou určenou zadaným obrázkom a výsledok nakreslí do tohto obrázka.
`void`	`vypln(Shape tvar, String súbor)` Alias pre `vypln`.
`void`	`vyplň(Shape tvar, String súbor)` Vyplní zadaný tvar textúrou prečítanou zo súboru s obrázkom a výsledok nakreslí do obrázka.
`void`	`vypln(String súbor)` Alias pre `vyplň`.
`void`	`vyplň(String súbor)` Vyplní obrázok zadanou textúrou.
`BufferedImage`	`vyrobMasku()` Vyrobí z tohto obrázka masku priehľadnosti.
`boolean`	`vyrobMasku(BufferedImage nováMaska)` Vyrobí z tohto obrázka do zadaného obrázka masku priehľadnosti.
`double`	`vyska()` Alias pre `výška`.
`void`	`vyska(double výška)` Alias pre `výška`.
`double`	`výška()` Vráti šírku obrázka.
`void`	`výška(double výška)` Implementácia metódy rozhrania `Rozmer` určenej na nastavenie výšky obrázka.
`void`	`zastav()` Zastaví prehrávanie animácie tohto obrázka.
`void`	`zastavAnimaciu()` Alias pre `zastav`.
`void`	`zastavAnimáciu()` Alias pre `zastav`.
`Obrazok`	`zmenVelkost(double mierka)` Alias pre `zmeňVeľkosť`.
`Obrázok`	`zmeňVeľkosť(double mierka)` Vyrobí nový novú verziu tohto obrázka, ktorej zmení veľkosť podľa zadanej mierky.
`Obrazok`	`zmenVelkost(int nováŠírka, int nováVýška)` Alias pre `zmeňVeľkosť`.
`Obrázok`	`zmeňVeľkosť(int nováŠírka, int nováVýška)` Vyrobí nový novú verziu tohto obrázka, ktorej zmení veľkosť podľa zadaných rozmerov.
`void`	`zrusKreslica()` Alias pre `zrušKresliča`.
`void`	`zrusPriehladnost()` Alias pre `zrušPriehľadnosť`.
`void`	`zrušKresliča()` Zruší kresliča obrázka.
`void`	`zrušPriehľadnosť()` Zruší priehľadnosť všetkých bodov v obrázku.

Metódy zdedené z triedy java.awt.Image
flush, getAccelerationPriority, getCapabilities, getScaledInstance, setAccelerationPriority

Metódy zdedené z triedy java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Podrobnosti atribútov
  - šírka
```
public final int šírka
```
    Šírka obrázka. Konštanta má rovnakú hodnotu, akú vracia metóda šírka.
  - sirka
```
public final int sirka
```
    Šírka obrázka. Konštanta má rovnakú hodnotu, akú vracia metóda šírka.
  - výška
```
public final int výška
```
    Výška obrázka. Konštanta má rovnakú hodnotu, akú vracia metóda výška.
  - vyska
```
public final int vyska
```
    Výška obrázka. Konštanta má rovnakú hodnotu, akú vracia metóda výška.
  - grafika
```
public final Graphics2D grafika
```
    Grafika obrázka (pre potreby kreslenia do obrázka). Robot má dostatok nástrojov (metód) na kreslenie. Ak potrebujete priamy prístup ku grafickému objektu obrázka (a využívať jeho metódy – ide o triedu Graphics2D), použite na prístup k nemu túto konštantu alebo metódu grafika, ktorá vracia rovnaký objekt. Používajte tento objekt ojedinele, pretože inštancie triedy obrázok mierne prispôsobujú svoj súradnicový priestor, aby boli lepšie použiteľné v prostredí programovacieho rámca grafického robota.
    
    Poznámka: Súradnicový priestor obrázka je posunutý tak, aby počiatok súradnicovej sústavy grafického robota ležal v strede obrázka. Predpokladá sa, že všetky objekty smerujúce do obrázka budú generované robotom a ten generuje tvary tak, aby boli priamo použiteľné v súradnicovom priestore Javy, ibaže v prepočte vzhľadom k rozmerom plátien, preto má obrázok svoj priestor posunutý. O súradnicových priestoroch sa podrobnejšie píše napríklad v opisoch metód GRobot.cesta(), SVGpodpora.zapíš(…), SVGpodpora.čítaj(meno) a priebežne v celej dokumentácii.
- Podrobnosti konštruktorov
  - Obrázok
```
public Obrázok()
```
    Predvolený konštruktor. Vytvorí nový prázdny obrázok s rozmermi plátna.
  - Obrázok
```
public Obrázok(int šírka,
               int výška)
```
    Konštruktor, ktorý vytvorí nový prázdny obrázok so zadanými rozmermi (v bodoch).
    
    Parametre:
    
    šírka – šírka nového obrázka
    
    výška – výška nového obrázka
  - Obrázok
```
public Obrázok(Image obrázok)
```
    Vytvorí nový obrázok podľa zadaného obrázka ako predlohy. Nový obrázok bude mať rozmery aj obsah predlohy. Konštruktor najskôr vytvorí prázdny obrázok s rozmermi predlohy a potom do neho prekreslí obsah predlohy. Ak potrebujete vytvoriť nový obrázok prečítaný zo súboru, použite metódu Obrázok.čítaj(názovSúboru).
    
    Parametre:
    
    obrázok – obrázoky predlohy
- Podrobnosti metód
  - priečinokObrázkov
```
public static void priečinokObrázkov(String priečinok)
```
    Ak sú všetky obrázky uložené v spoločnom priečinku, môžeme pre nich touto metódou nastaviť zdrojový priečinok čítania. Priečinok by sa mal nachádzať v hlavnom priečinku projektu alebo by k nemu mala viesť systémovo nezávislá relatívna cesta. Zadaním prázdneho reťazca alebo hodnoty null používanie priečinka zrušíme.
    
    Cesta je používaná pri čítaní všetkých obrázkov, okrem čítania z archívu. Čiže napríklad pri čítaní metódou čítaj(súbor), vypĺňaní metódami GRobot.vyplňTvar(tvar, súbor), GRobot.vyplňOblasť(oblasť, súbor) (atď.), kreslení metódami GRobot.obrázok(súbor), Plátno.obrázok(súbor) (atď.), ale aj pri nastavovaní vlastného tvaru robota GRobot.vlastnýTvar(súbor) a v mnohých iných situáciách (pozri aj metódu Svet.priečinokObrázkov(priečinok)).
    
    Parametre:
    
    priečinok – názov priečinka, relatívna cesta, prípadne prázdny reťazec alebo null
    
    Pozri tiež:
    
    priečinokObrázkov(), Svet.priečinokObrázkov()
  - priecinokObrazkov
```
public static void priecinokObrazkov(String priečinok)
```
    Alias pre priečinokObrázkov.
  - priečinokObrázkov
```
public static String priečinokObrázkov()
```
    Vráti reťazec s aktuálnym priečinkom, z ktorého sú obrázky prečítané. Reťazec je obohatený o oddeľovací znak priečinkov java.io.File.separatorChar (/ alebo \ – záleží na type operačného systému), ktorý automaticky pridáva metóda priečinokObrázkov(priečinok). Rovnako všetky oddeľovacie znaky priečinkov v relatívnej ceste sú nahradené podľa typu operačného systému.
    
    Návratová hodnota:
    
    aktuálny priečinok, z ktorého sú obrázky prečítané
    
    Pozri tiež:
    
    priečinokObrázkov(String), Svet.priečinokObrázkov(String)
  - priecinokObrazkov
```
public static String priecinokObrazkov()
```
    Alias pre priečinokObrázkov.
  - čítaj
```
public static Obrázok čítaj(String súbor)
```
    Prečíta do vnútornej pamäte sveta zadaný obrázok zo súboru a vytvorí z neho nový objekt typu Obrázok.
    
    Táto metóda uzatvára funkcionalitu metódy Svet.čítajObrázok(súbor), ibaže naviac z objektu typu Image (ktorý zostáva uložený vo vnútornej pamäti sveta) automaticky vytvára nový objekt Obrázok.
    
    Obrázok prečítaný zo súboru je chápaný ako zdroj a po prečítaní zostane uložený vo vnútornej pamäti sveta. Z nej môže byť v prípade potreby (napríklad ak sa obsah súboru na disku zmenil) odstránený metódou Svet.uvoľni(názovZdroja). (Táto informácia je platná pre všetky metódy pracujúce s obrázkami alebo zvukmi, ktoré prijímajú názov súboru ako parameter.)
    
    Táto metóda je schopná čítať aj animácie uložené vo formáte GIF (z dôvodu obmedzení tohto formátu ho neodporúčame používať na ukladanie nových animácií) a tiež sekvencie uložené v číslovaných obrázkových súboroch vo formáte PNG (čo je lepšia alternatíva na ukladanie plnofarebných animácií; pri použití tejto verzie metódy má však tú nevýhodu, že nevie automaticky uložiť informácie o trvaní zobrazenia jednotlivých snímok a predvolene pracuje s hodnotou 40 ms nastavenou pre každú snímku; túto nevýhodu nemá čítanie sekvencie z archívu – pozri poznámku nižšie). Podrobnejšie informácie o PNG sekvenciách sú v opise metódy ulož(súbor, prepísať).
    
    Upozornenie: Pri čítaní animácie z PNG sekvencie (príklad s PNG sekvenciou je uvedený nižšie, pod príkladom s animovaným GIFom) sú do vnútorného zoznamu zdrojov sveta uložené všetky obrázky sekvencie. To je ďalšia nevýhoda, lebo obrazové informácie snímok sú uchovávané duplicitne. Túto nevýhodu nemá čítanie sekvencie z archívu (pozri poznámku nižšie).
    
    Poznámka: Od verzie 2.18 sa PNG sekvencie dajú jednoducho čítať aj z archívu (ZIP). Výhodou je uchovanie celej animácie v jednom súbore, úspora vnútornej pamäte programovacieho rámca a tiež automatické uchovanie informácií o časovaní snímok (v samostatnej položke archívu). Pozri aj príklad v opise metódy Obrázok.čítaj(archív, názovPoložky).
    
    Príklad:
    
    Ako bolo povedané, programovací rámec dokáže čítať a pracovať s animovanými obrázkami vo formáte GIF. Je to historický formát s určitými (najmä farebnými) obmedzeniami, ale stále nachádza svoje použitie. Nasledujúci príklad ukazuje, ako takýto súbor prečítať a animovať s použitím programovacieho rámca GRobot.
    
    srdce.gif – animovaný obrázok na prevzatie, ktorý potrebuje tento príklad na to, aby fungoval
```
import knižnica.*;

public class AnimujGIF extends GRobot
{
    // Súkromná statická inštancia obrázka, ktorý budeme animovať. Statickosť
    // umožňuje jej použitie v hlavnej metóde, ktorá musí byť statická.
    private static Obrázok animovanýObrázok;

    // Hlavná metóda. (Obvykle ju umiestňujeme na koniec súboru. Je to taká
    // dohoda, zvyk medzi programátormi v Jave, ale z pohľadu samotného jazyka
    // je jedno, kde je jej definícia umiestnená. Teraz sme ju presunuli sem,
    // lebo na komentáre v nej logicky nadväzujú komentáre v konštruktore
    // tejto triedy.)
    public static void main(String... args)
    {
        // Skryjeme svet (čiže okno aplikácie).
        Svet.skry();

        // Vopred prečítame animovaný obrázok zo súboru, aby sme podľa jeho
        // rozmerov mohli upraviť rozmery sveta v konštruktore:
        animovanýObrázok = Obrázok.čítaj("srdce.gif");

        // Vytvorenie anonymnej inštancie tejto triedy (konštruktor triedy
        // odvodenej od robota vždy zabezpečí vytvorenie aplikácie):
        new AnimujGIF();

        // Spustenie animácie:
        animovanýObrázok.spusti();

        // Spustenie časovača:
        Svet.spustiČasovač(0.020);

        // Automatické nastavenie veľkosti a polohy okna sveta (t. j.
        // aplikácie) a jeho zobrazenie:
        Svet.zbaľ();
        Svet.vystreď();
        Svet.zobraz();
    }

    // Súkromný konštruktor.
    private AnimujGIF()
    {
        // Spustenie tej verzie nadradeného konštruktora, ktorá umožňuje
        // zmeniť rozmery plátien sveta:
        super(animovanýObrázok.šírka, animovanýObrázok.výška);

        // Skrytie robota:
        skry();
    }

    // Reakcia na časovač – pravidelne prekresľuje animovaný obrázok, ktorého
    // animácia je vykonávaná automaticky (vnútornými mechanizmami sveta).
    @Override public void tik()
    {
        if (Svet.neboloPrekreslené())
        {
            podlaha.vymažGrafiku();
            obrázok(animovanýObrázok);
        }
    }
}
```
    Výsledok:
    
    Táto animácia bude zobrazená v okne aplikácie.
    
    Príklad:
    
    Tento príklad ukazuje ako prečítať PNG sekvenciu s použitím rovnakej šablóny názvu súborov, akú používa druhý príklad uvedený v opise metódy ulož(súbor, prepísať). Dotknutý príklad generuje súbory použiteľné s týmto príkladom, preto je vhodné sa zaoberať najskôr ním. (Generovanie môže trvať aj sedem minút, podľa výkonnosti hadvéru, a vygenerované súbory budú dohromady zaberať okolo 120 MB.)
    
    V súlade s informáciami uvedenými v opise metódy ulož(súbor, prepísať) platí, že ak táto metóda pri čítaní sekvencie nájde súbor s poradovým číslom nula, tak ho prečíta ako neanimovaný obrázok a už sa nepokúša hľadať ďalšie súbory vyhovujúce kritériám šablóny názvov súborov animovanej sekvencie. Inak postupuje pri čítaní systematicky a pridáva snímky do prečítanej animácie dovtedy, kým jestvujú súbory v neprerušenej sekvencii podľa určenej šablóny.
    
    Poznámka: Metóda ulož(súbor, prepísať) dokáže vygenerovať len PNG sekvenciu, ale táto metóda (čítaj(súbor)) je schopná prečítať aj sekvenciu vo formáte JPEG. JPEG je stratový formát a neumožňuje ukladanie (polo)priehľadných bodov. Je však vhodný na ukladanie fotografií, kde sa jeho kompresné artefakty vizuálne strácajú (opticky zanikajú v grafickej komplikovanosti obrazu), čím sa lepšie uplatňuje jeho kompresný benefit. JPEG sekvencie môžete použiť na simulovanie prehrávania videa, ak takú sekvenciu vyrobíte s použitím externého softvéru a zachováte pravidlá pomenovania šablón s rozdielom prípony – namiesto .png musí byť uvedená .jpg alebo .jpeg
```
import knižnica.*;

public class AnimujSekvenciuPNG extends GRobot
{
    // Inštancia obrázka, ktorý bude obsahovať a animovať prečítanú sekvenciu.
    private Obrázok animovanýObrázok;

    // Aktuálne „percento“ prečítaných snímok vypočítané v reakcii „sekvencia“
    // (v skutočnosti hodnota v rozsahu od 0.0 do 1.0, ktorá je použitá na
    // zobrazenie percent):
    private double percento = 0.0;

    // Nastavenie začiatočného stavu aplikácie (po prečítaní sekvencie sa
    // zmení na false):
    private boolean čítam = true;

    // Názov naposledy prečítaného súboru sekvencie:
    private String naposledyPrečítaný = "";

    // Súkromný konštruktor.
    private AnimujSekvenciuPNG()
    {
        // Spustenie tej verzie nadradeného konštruktora, ktorá umožňuje
        // zmeniť rozmery plátien sveta:
        super(Svet.šírkaObrázka("sekvencia/nahodne-ciary-001.png"),
            Svet.výškaObrázka("sekvencia/nahodne-ciary-001.png"));

        // Počas čítania pozastavíme automatické prekresľovanie (aby
        // kreslenie v reakcii sekvencia „neblikalo“):
        Svet.nekresli();

        // Automatické nastavenie veľkosti a polohy okna sveta
        // (t. j. aplikácie):
        Svet.zbaľ();
        Svet.vystreď();

        // Skrytie robota:
        skry();

        // Spustíme časomieru, pretože chceme vedieť ako dlho potrvá čítanie
        // PNG sekvencie a časovač, aby mohlo byť aktualizované zobrazovanie
        // priebehu čítania:
        Svet.spustiČasomieru();
        Svet.spustiČasovač(0.250);

        // Prečítanie PNG sekvencie:
        animovanýObrázok = Obrázok.čítaj("sekvencia/nahodne-ciary-***.png");

        // Zastavíme časomieru aj časovač a zobrazíme výsledok (na konzole):
        double čas = Svet.zastavČasomieru();
        Svet.zastavČasovač();
        System.out.println("Čítanie animácie trvalo: " +
            Math.round(čas / 60) + " min " + F(čas % 60, 2) + " s");

        // Prečítané – odteraz treba zobrazovať animáciu:
        čítam = false;

        // Nastavíme čiernu farbu pozadia:
        Svet.farbaPozadia(čierna);

        // A spustíme animáciu a časovač:
        animovanýObrázok.spusti();
        Svet.spustiČasovač(0.040);

        // Obnovíme automatické prekresľovanie, aby sme videli priebeh
        // animácie:
        Svet.kresli();
    }

    // Táto reakcia je automaticky spúšťaná počas čítania (alebo zápisu)
    // animovanej PNG sekvencie. Používame ju na aktualizovanie informácie
    // o stave čítania zobrazenej na obrazovke pre používateľa cez reakciu tik.
    @Override public void sekvencia(int kódSpracovania, String zdroj,
        String cieľ, long stav, long celkovo)
    {
        // Vypočítame percento prečítanej animácie a uložíme názov súboru:
        percento = (double)stav / (double)celkovo;
        naposledyPrečítaný = zdroj;

        // Žiadame prekreslenie, čo bude spracované v reakcii tik:
        Svet.žiadajPrekreslenie();
    }

    // Reakcia na časovač – pravidelne prekresľuje animovaný obrázok, ktorého
    // animácia je vykonávaná automaticky (vnútornými mechanizmami sveta).
    @Override public void tik()
    {
        if (Svet.neboloPrekreslené())
        {
            // Reakcia slúži na zobrazovanie priebehu čítania aj na
            // zobrazovanie prečítanej animácie. V obidvoch prípadoch najprv
            // vymažeme grafiku podlahy:
            podlaha.vymažGrafiku();

            // Potom podľa stavu aplikácie zobrazíme priebeh alebo animovaný
            // obrázok:
            if (čítam)
            {
                // Nasledujúce príkazy kreslia jednoduchý ukazovateľ priebehu
                // obsahujúci informačný text o aktuálnom percente a naposledy
                // prečítanom súbore:

                skoč(percento * 200 - 200, 0);
                farba(svetlošedá);
                vyplňObdĺžnik(percento * 200, 10);

                farba(čierna);
                skočNa(0, 0);
                kresliObdĺžnik(200, 10);
                text(F(percento * 100.0, 0) + " % (" +
                    naposledyPrečítaný + ")");

                // Prekreslíme obrazovku, aby bolo vidno aktuálny stav
                // priebehu:
                Svet.prekresli();
            }
            else
                obrázok(animovanýObrázok);
        }
    }

    // Hlavná metóda.
    public static void main(String... args)
    {
        // Vytvorenie anonymnej inštancie tejto triedy (konštruktor triedy
        // odvodenej od robota vždy zabezpečí vytvorenie aplikácie):
        new AnimujSekvenciuPNG();
    }
}
```
    Opis priebehu a výsledku:
    
    Počas čítania bude na obrazovke premietaný stav priebehu čítania s názvom naposledy prečítaného súboru. Kód spracovania reakcie sekvencia sme v príklade nepoužili. V tomto prípade mal hodnotu konštanty ČÍTANIE_PNG_SEKVENCIE. (V prípade čítania animáce z formátu GIF je hodnota rovná hodnote konštanty ČÍTANIE_GIF_ANIMÁCIE.) Podľa nami nameraných hodnôt trvalo čítanie sekvencie od osem do dvanásť sekúnd.
    
    Výsledkom vykonania tohto príkladu bude spustenie animácie prečítanej zo sekvencie súborov vo formáte PNG (uloženej na disku). Grafické súbory potrebné na fungovanie tohto príkladu je schopný vytvoriť v poradí druhý príklad uvedený v opise metódy ulož(súbor, prepísať) (preto je vhodné sa zaoberať najskôr ním).
    
    Ukážky možného vzhľadu prečítanej animáce, ak bola sekvencia vygenerovaná príkladom z opisu metódy ulož(súbor, prepísať) (plátno ukážok je úmyselne zmenšené).
    
    Na 32-bitových operačných systémoch sa môže stať, že aplikácia nebude mať dostatok pamäte na vykonanie. V takom prípade skúste cez príkazový riadok operačného systému spustiť aplikáciu nasledujúcim príkazom potvrdeným v priečinku s preloženou aplikáciou:
```
java -Xmx1g AnimujSekvenciuPNG
```
    V prípade, že táto metóda nenájde dostatok miesta v pamäti na prečítanie celej sekvencie, tak uvoľní obrázok z pamäti a vráti hodnotu null. Tiež upozorní všetky inštancie sledujúce čítanie sekvencie reakciou sekvencia a/alebo aktívnu obsluhu udalostí s definovanou reakciou sekvencia poslaním informácií platných v čase zlyhania s kódom spracovania CHYBA_ČÍTANIA_PNG_SEKVENCIE.
    Parametre:
    
    súbor – názov súboru s obrázkom
    
    Návratová hodnota:
    
    obrázok v novom objekte typu Obrázok (prípadne null ak pokus o prečítanie sekvencie zlyhal z pamäťových dôvodov)
    
    Výnimky:
    
    GRobotException – ak súbor s obrázkom nebol nájdený (identifikátor imageNotFound)
    
    Pozri tiež:
    
    Svet.priečinokObrázkov(String)
  - citaj
```
public static Obrazok citaj(String súbor)
```
    Alias pre čítaj.
  - prečítaj
```
public static Obrázok prečítaj(String súbor)
```
    Alias pre čítaj.
  - precitaj
```
public static Obrazok precitaj(String súbor)
```
    Alias pre čítaj.
  - čítaj
```
public static Obrázok čítaj(Archív archív,
                            String názovPoložky)
```
    Prečíta do vnútornej pamäte sveta obrázok zo zadaného archívu a vytvorí z neho nový objekt typu Obrázok. Archív musí byť vopred otvorený na čítanie. Inak metóda funguje veľmi podobne ako metóda čítaj(súbor).
    
    Obrázok prečítaný z archívu je chápaný ako objekt a po prečítaní zostáva uložený vo vnútornej pamäti sveta. Z nej môže byť v prípade potreby odstránený metódou Svet.uvoľni(ktorý) (kde ktorý je inštancia obrázka).
    
    Táto metóda neberie do úvahy nastavenie priečinka obrázkov. Ak je obrázok v archíve uložený v nejakom priečinku, treba ako názov položky uviesť celú cestu.
    
    Upozornenie: Táto metóda je použiteľná len v prípade, že je archív otvorený na čítanie.
    
    Príklad:
    
    Nižšie sú fragmenty kódu, ktorými sa dá zapísať aj prečítať PNG sekvencia z archívu. Kód treba korektne uzavrieť do štruktúr try-catch, obrázok na zápis treba vopred pripraviť (naprogramovať jeho vyrobenie), ale inak je kód pripravený na použitie.
    
    Poznámka: Pri zápise a čítaní PNG sekvencie v archíve sú automaticky uchovávané informácie o časovaní snímok v samostatnej položke archívu, ktorej názov je odvodený zo šablóny PNG sekvencie. Čítanie PNG sekvencie z archívu má aj tú výhodu, že parciálne obrázky sekvencie nie sú duplicitne ukladané v pamäti sveta.
```
// (deklarácie)
Archív archív = new Archív();
Obrázok obrázok = /*… obrázok treba vytvoriť …*/;

// Takto sa dá obrázok zapísať:
archív.otvorNaZápis("archív-png.zip");
obrázok.ulož(archív, "názov-*.png");
archív.zavri();

// prípadne takto:
archív.otvorNaZápis("archív-png.zip");
archív.pridajPoložku("názov-*.png", obrázok);
archív.zavri();


// A takto potom prečítať
archív.otvorNaČítanie("archív-png.zip");
obrázok = Obrázok.čítaj(archív, "názov-*.png");
archív.zavri();

// prípadne takto:
archív.otvorNaČítanie("archív-png.zip");
obrázok = archív.obrázok("názov-*.png");
archív.zavri();
```
    Parametre:
    
    archív – archív, z ktorého má byť obrázok prečítaný
    
    názovPoložky – názov položky s obrázkom v archíve (vrátane úplnej cesty) alebo šablóna sekvencie animácie
    
    Návratová hodnota:
    
    obrázok v novom objekte typu Obrázok (prípadne null, ak pokus o prečítanie sekvencie zlyhal z pamäťových dôvodov)
    
    Výnimky:
    
    GRobotException – ak archív nie je otvorený na čítanie (identifikátor archiveNotOpenForReading) alebo zadaná položka s obrázkom nebola nájdená (identifikátor entryNotFound)
    
    Pozri tiež:
    
    ulož(Archív, String), Archív.obrázok(String), Archív.pridajPoložku(String, Obrázok)
  - citaj
```
public static Obrazok citaj(Archív archív,
                            String názovPoložky)
```
    Alias pre čítaj.
  - prečítaj
```
public static Obrázok prečítaj(Archív archív,
                               String názovPoložky)
```
    Alias pre čítaj.
  - precitaj
```
public static Obrazok precitaj(Archív archív,
                               String názovPoložky)
```
    Alias pre čítaj.
  - šírka
```
public double šírka()
```
    Vráti šírku obrázka. Ide prakticky o rovnaký údaj, aký je uložený v konštante šírka, ibaže vo forme reálneho čísla, keďže inde zároveň o implementáciu metódy rozhrania Rozmer.
    
    Definované:
    
    šírka v rozhraní Rozmer
    
    Návratová hodnota:
    
    šírka obrázka
  - sirka
```
public double sirka()
```
    Alias pre šírka.
    
    Definované:
    
    sirka v rozhraní Rozmer
  - výška
```
public double výška()
```
    Vráti šírku obrázka. Ide prakticky o rovnaký údaj, aký je uložený v konštante výška, ibaže vo forme reálneho čísla, keďže inde zároveň o implementáciu metódy rozhrania Rozmer.
    
    Definované:
    
    výška v rozhraní Rozmer
    
    Návratová hodnota:
    
    výška obrázka
  - vyska
```
public double vyska()
```
    Alias pre výška.
    
    Definované:
    
    vyska v rozhraní Rozmer
  - šírka
```
public void šírka(double šírka)
```
    Implementácia metódy rozhrania Rozmer určenej na nastavenie šírky obrázka. Keďže je však obrázok rozmerovo nemenný (angl. immutable), produkuje táto metóda vždy výnimku GRobotException s identifikátorom imageSizeImmutable.
    
    Definované:
    
    šírka v rozhraní Rozmer
    
    Výnimky:
    
    GRobotException – vždy – obrázok je rozmerovo nemenný (identifikátor imageSizeImmutable)
  - sirka
```
public void sirka(double šírka)
```
    Alias pre šírka.
    
    Definované:
    
    sirka v rozhraní Rozmer
  - výška
```
public void výška(double výška)
```
    Implementácia metódy rozhrania Rozmer určenej na nastavenie výšky obrázka. Keďže je však obrázok rozmerovo nemenný (angl. immutable), produkuje táto metóda vždy výnimku GRobotException s identifikátorom imageSizeImmutable.
    
    Definované:
    
    výška v rozhraní Rozmer
    
    Výnimky:
    
    GRobotException – vždy – obrázok je rozmerovo nemenný (identifikátor imageSizeImmutable)
  - vyska
```
public void vyska(double výška)
```
    Alias pre výška.
    
    Definované:
    
    vyska v rozhraní Rozmer
  - rozmery
```
public Rozmer rozmery()
```
    Vráti rozmery obrázka v implementácii rozhrania Rozmer. Konkrétne ide o inštanciu triedy Rozmery.
    
    Definované:
    
    rozmery v rozhraní Rozmer
    
    Návratová hodnota:
    
    inštancia rozmerov tohto obrázka
  - rozmery
```
public void rozmery(Rozmer rozmer)
```
    Implementácia metódy rozhrania Rozmer určenej na nastavenie obidvoch rozmerov obrázka. Keďže je však obrázok rozmerovo nemenný (angl. immutable), produkuje táto metóda vždy výnimku GRobotException s identifikátorom imageSizeImmutable.
    
    Definované:
    
    rozmery v rozhraní Rozmer
    
    Výnimky:
    
    GRobotException – vždy – obrázok je rozmerovo nemenný (identifikátor imageSizeImmutable)
  - máŠírku
```
public boolean máŠírku(double šírka)
```
    Overí zhodu šírky obrázka so zadanou hodnotou.
    
    Definované:
    
    máŠírku v rozhraní Rozmer
    
    Parametre:
    
    šírka – hodnota šírky na porovnanie
    
    Návratová hodnota:
    
    true ak sa šírka obrázka zhoduje so zadanou hodnotou, false v opačnom prípade
  - maSirku
```
public boolean maSirku(double šírka)
```
    Alias pre máŠírku.
    
    Definované:
    
    maSirku v rozhraní Rozmer
  - máVýšku
```
public boolean máVýšku(double výška)
```
    Overí zhodu výšky obrázka so zadanou hodnotou.
    
    Definované:
    
    máVýšku v rozhraní Rozmer
    
    Parametre:
    
    výška – hodnota výšky na porovnanie
    
    Návratová hodnota:
    
    true ak sa výška obrázka zhoduje so zadanou hodnotou, false v opačnom prípade
  - maVysku
```
public boolean maVysku(double výška)
```
    Alias pre máVýšku.
    
    Definované:
    
    maVysku v rozhraní Rozmer
  - máRozmer
```
public boolean máRozmer(double šírka,
                        double výška)
```
    Overí zhodu rozmerov obrázka so zadanými rozmermi.
    
    Definované:
    
    máRozmer v rozhraní Rozmer
    
    Parametre:
    
    šírka – hodnota šírky na porovnanie
    
    výška – hodnota výšky na porovnanie
    
    Návratová hodnota:
    
    true ak sa rozmery obrázka zhodujú so zadanými rozmermi, false v opačnom prípade
  - maRozmer
```
public boolean maRozmer(double šírka,
                        double výška)
```
    Alias pre máRozmer.
    
    Definované:
    
    maRozmer v rozhraní Rozmer
  - máRozmer
```
public boolean máRozmer(Rozmer rozmer)
```
    Overí zhodu rozmerov obrázka s rozmermi zadaného objektu.
    
    Definované:
    
    máRozmer v rozhraní Rozmer
    
    Parametre:
    
    rozmer – iný objekt, ktorého rozmery majú byť porovnané s rozmermi obrázka
    
    Návratová hodnota:
    
    true ak sa rozmery obrázka zhodujú s rozmermi zadaného objektu, false v opačnom prípade
  - maRozmer
```
public boolean maRozmer(Rozmer rozmer)
```
    Alias pre máRozmer.
    
    Definované:
    
    maRozmer v rozhraní Rozmer
  - zmeňVeľkosť
```
public Obrázok zmeňVeľkosť(double mierka)
```
    Vyrobí nový novú verziu tohto obrázka, ktorej zmení veľkosť podľa zadanej mierky.
    
    Príklad:
```
import knižnica.*;

public class TestZmenyVeľkosti extends GRobot
{
    private final Zoznam<Obrázok> obrázky = new Zoznam<Obrázok>();

    private TestZmenyVeľkosti()
    {
        // Najprv vyrobíme a nakreslíme obrázok:
        Obrázok obrázok = new Obrázok(100, 100);

        kresliNaObrázok(obrázok);
        farba(žltá);
        vyplň();
        hrúbkaČiary(1);
        farba(červená);
        kružnica(45);
        farba(zelená);
        štvorec(25);

        farba(tyrkysová);
        hrúbkaČiary(2);
        for (int i = 0; i < 18; ++i)
        {
            skočNa(0, 0);
            vpravo(20);
            dopredu(47);
        }

        domov();
        farba(modrá);
        kruh(5);

        kresliNaPodlahu();

        // Potom postupne zmeníme jeho rozmer v rozmedzí mierok 0.33 – 3.0…
        for (double mierka = 0.33; mierka <= 3.0; mierka += 0.025)
        {
            veľkosť(10 * mierka);   // nepovinné – veľkosť robota bude
                                    // indikovať fázu procesu
            obrázky.pridaj(obrázok.zmeňVeľkosť(mierka));
        }

        // …a späť. (Obrázky so zmenenou veľkosťou ukladáme do zoznamu.)
        for (double mierka = 3.0; mierka >= 0.33; mierka -= 0.025)
        {
            veľkosť(10 * mierka);   // nepovinné – veľkosť robota bude
                                    // indikovať fázu procesu
            obrázky.pridaj(obrázok.zmeňVeľkosť(mierka));
        }

        // Konštantná uhlová rýchlosť zabezpečí rotáciu obrázka
        uhlováRýchlosť(0.5);
    }

    @Override public void aktivita()
    {
        // Zmena vlastného tvaru robota postupným výberom prvkov zoznamu
        // zabezpečí ukážku kontinuálnej zmeny obrázka v rozmedzí mierok,
        // ktoré sme použili v konštruktore.
        vlastnýTvar(obrázky.ďalší());
    }

    public static void main(String[] args)
    {
        new TestZmenyVeľkosti();
    }
}
```
    Výsledok:
    
    Ukážka výsledku – jedna z verzií zväčšeného obrázka vo fáze otáčania sa okolo svojej osi.
    Parametre:
    
    mierka – mierka 0.5 znamená, že výsledný obrázok bude polovičný; mierka 2.0 znamená, že výsledný obrázok bude dvojnásobný
    
    Návratová hodnota:
    
    nová verzia obrázka (v novom objekte typu Obrázok)
  - zmenVelkost
```
public Obrazok zmenVelkost(double mierka)
```
    Alias pre zmeňVeľkosť.
  - zmeňVeľkosť
```
public Obrázok zmeňVeľkosť(int nováŠírka,
                           int nováVýška)
```
    Vyrobí nový novú verziu tohto obrázka, ktorej zmení veľkosť podľa zadaných rozmerov.
    
    Parametre:
    
    nováŠírka – šírka novej verzie obrázka
    
    nováVýška – šírka novej verzie obrázka
    
    Návratová hodnota:
    
    nová verzia obrázka (v novom objekte typu Obrázok)
  - zmenVelkost
```
public Obrazok zmenVelkost(int nováŠírka,
                           int nováVýška)
```
    Alias pre zmeňVeľkosť.
  - grafika
```
public Graphics2D grafika()
```
    Vráti objekt grafiky obrázka (pre potreby kreslenia do obrázka). Robot má dostatok nástrojov (metód) na kreslenie. Ak potrebujete priamy prístup ku grafickému objektu obrázka (a využívať jeho metódy – ide o triedu Graphics2D), použite na prístup k nemu túto metódu alebo konštantu grafika, ktorá obsahuje rovnaký objekt, aký vracia táto metóda. Používajte tento objekt ojedinele, pretože inštancie triedy obrázok mierne prispôsobujú svoj súradnicový priestor, aby boli lepšie použiteľné v prostredí programovacieho rámca grafického robota.
    
    (Na spresnenie: Súradnicový priestor obrázka je posunutý tak, aby počiatok súradnicovej sústavy programovacieho rámca GRobot ležal v strede obrázka. Predpokladá sa totiž, že všetky objekty tvarov určené na nakreslenie do obrázka budú generované robotom a ten generuje tvary tak, aby boli priamo použiteľné v súradnicovom priestore Javy, ibaže v prepočte vzhľadom k rozmerom plátien, preto má obrázok svoj priestor posunutý. Viac sa o súradnicových priestoroch píše napríklad v opisoch metód GRobot.cesta(), SVGpodpora.zapíš(…), SVGpodpora.čítaj(meno) a tiež priebežne v celej dokumentácii.)
    
    Návratová hodnota:
    
    objekt typu Graphics2D – grafika obrázka
  - kresliVšade
```
public void kresliVšade()
```
    Zruší oblasť na obmedzenie kreslenia na tento obrázok.
    
    Pozri tiež:
    
    GRobot.kresliVšade(), kresliDo(Shape), nekresliDo(Shape)
  - kresliVsade
```
public void kresliVsade()
```
    Alias pre kresliVšade.
  - kresliDo
```
public void kresliDo(Shape tvar)
```
    Obmedzí kreslenie na tento obrázok na plochu zadaného útvaru (Shape).
    
    Robot disponuje množinou metód na kreslenie tvarov (kružnica, elipsa, štvorec…), ktoré zároveň generujú tvary. Na ich použitie s touto metódou je dobré predtým kreslenie tvarov zakázať a neskôr opäť povoliť. Metóda text dokonca zákaz kreslenia tvarov požaduje, aby mohla vygenerovať tvar (bez zákazu má návratovú hodnotu null). Tvar je možné vytvoriť aj z cesty…
    
    Obmedzenie zužuje aktuálny priestor kreslenia, to znamená, že sa priebežne vytvára oblasť, ktorá je prienikom všetkých obmedzení. Ak chceme vytvoriť obmedzenie tvaru, ktorý je možné vytvoriť inou množinovou operáciou, môžeme na obmedzenie kreslenia použiť Oblasť (zadanú namiesto parametra tvar). Obmedzenia sú platné pre všetky roboty a zrušíme ich volaním metódy kresliVšade.
    
    Poznámka: Pri takomto orezávaní nie je na všetkých platformách a/alebo implementáciách virtuálneho stroja Javy dostupná funkcia anti-aliasingu, čo zjednodušene povedané znamená, že okraje orezanej kresby môžu byť „zúbkaté.“ Ak sa chcete tejto nedokonalosti vyhnúť, použite radšej funkciu masky. Tá dovoľuje ovplyvňovať úroveň priehľadnosti s jemnosťou na jednotlivé body rastra. (Poznámka: Naopak, pri exporte kreslenia do inštancie SVGPodpora je výhodnejšie pracovať s orezávaním – čiže práve s touto metódou alebo jej variantmi.)
    
    Parametre:
    
    tvar – tvar (Shape) alebo Oblasť
    
    Pozri tiež:
    
    GRobot.kresliDo(Shape), kresliVšade(), nekresliDo(Shape)
  - nekresliDo
```
public void nekresliDo(Shape tvar)
```
    Vytvára obmedzenie kreslenia na tento obrázok. Funguje rovnako ako metóda kresliDo, ibaže obrátene – kreslenie je možné všade, okrem zadaného tvaru alebo oblasti.
    
    Rovnako ako pri metóde kresliDo, sa aj toto obmedzenie kombinuje s aktuálnymi obmedzeniami kreslenia a je platné pre všetky roboty. Všetky ombedzenia zrušíme volaním metódy kresliVšade.
    
    Poznámka: Pri takomto orezávaní nie je na všetkých platformách a/alebo implementáciách virtuálneho stroja Javy dostupná funkcia anti-aliasingu, čo zjednodušene povedané znamená, že okraje orezanej kresby môžu byť „zúbkaté.“ Ak sa chcete tejto nedokonalosti vyhnúť, použite radšej funkciu masky. Tá dovoľuje ovplyvňovať úroveň priehľadnosti s jemnosťou na jednotlivé body rastra. (Poznámka: Naopak, pri exporte kreslenia do inštancie SVGPodpora je výhodnejšie pracovať s orezávaním – čiže práve s touto metódou alebo jej variantmi.)
    
    Parametre:
    
    tvar – tvar (Shape) alebo Oblasť
    
    Pozri tiež:
    
    GRobot.nekresliDo(Shape), kresliDo(Shape), kresliVšade()
  - najmenšieX
```
public double najmenšieX()
```
    Zistí najmenšiu x-ovú súradnicu obrázka.
    
    Návratová hodnota:
    
    najmenšia x-ová súradnica obrázka
    
    Pozri tiež:
    
    najväčšieX(), najmenšieY(), najväčšieY()
  - najmensieX
```
public double najmensieX()
```
    Alias pre najmenšieX.
  - minimálneX
```
public double minimálneX()
```
    Alias pre najmenšieX.
  - minimalneX
```
public double minimalneX()
```
    Alias pre najmenšieX.
  - najmenšieY
```
public double najmenšieY()
```
    Zistí najmenšiu y-ovú súradnicu obrázka.
    
    Návratová hodnota:
    
    najmenšia y-ová súradnica obrázka
    
    Pozri tiež:
    
    najmenšieX(), najväčšieX(), najväčšieY()
  - najmensieY
```
public double najmensieY()
```
    Alias pre najmenšieY.
  - minimálneY
```
public double minimálneY()
```
    Alias pre najmenšieY.
  - minimalneY
```
public double minimalneY()
```
    Alias pre najmenšieY.
  - najväčšieX
```
public double najväčšieX()
```
    Zistí najväčšiu x-ovú súradnicu obrázka.
    
    Návratová hodnota:
    
    najväčšia x-ová súradnica obrázka
    
    Pozri tiež:
    
    najmenšieX(), najmenšieY(), najväčšieY()
  - najvacsieX
```
public double najvacsieX()
```
    Alias pre najväčšieX.
  - maximálneX
```
public double maximálneX()
```
    Alias pre najväčšieX.
  - maximalneX
```
public double maximalneX()
```
    Alias pre najväčšieX.
  - najväčšieY
```
public double najväčšieY()
```
    Zistí najväčšiu y-ovú súradnicu obrázka.
    
    Návratová hodnota:
    
    najväčšia y-ová súradnica obrázka
    
    Pozri tiež:
    
    najmenšieX(), najväčšieX(), najmenšieY()
  - najvacsieY
```
public double najvacsieY()
```
    Alias pre najväčšieY.
  - maximálneY
```
public double maximálneY()
```
    Alias pre najväčšieY.
  - maximalneY
```
public double maximalneY()
```
    Alias pre najväčšieY.
  - vymaž
```
public void vymaž()
```
    Vymaže obsah obrázka. V podstate vyplní obrázok priehľadnou farbou.
  - vymaz
```
public void vymaz()
```
    Alias pre vymaž.
  - prepíšBod
```
public void prepíšBod(double x,
                      double y,
                      Color farba)
```
    Prepíše farebné zložky a zložku priehľadnosti bodu na zadanej pozícii zadanou farbou.
    
    Parametre:
    
    x – x-ová súradnica bodu v súradnicovom priestore rámca
    
    y – y-ová súradnica bodu v súradnicovom priestore rámca
    
    farba – objekt určujúci novú farbu bodu
  - prepíšBod
```
public void prepíšBod(double x,
                      double y,
                      Farebnosť objekt)
```
    Prepíše farebné zložky a zložku priehľadnosti bodu na zadanej pozícii farbou zadaného objektu.
    
    Parametre:
    
    x – x-ová súradnica bodu v súradnicovom priestore rámca
    
    y – y-ová súradnica bodu v súradnicovom priestore rámca
    
    objekt – objekt určujúci novú farbu bodu
  - prepíšBod
```
public void prepíšBod(double x,
                      double y,
                      int farba)
```
    Prepíše farebné zložky a zložku priehľadnosti bodu na zadanej pozícii zadanou kombináciou zložiek ARGB zakódovaných v celočíselnej hodnote.
    
    Parametre:
    
    x – x-ová súradnica bodu v súradnicovom priestore rámca
    
    y – y-ová súradnica bodu v súradnicovom priestore rámca
    
    farba – celé číslo obsahujúce kombináciu farebných zložiek RGB a priehľadnosti
  - prepisBod
```
public void prepisBod(double x,
                      double y,
                      Color farba)
```
    Alias pre prepíšBod.
  - prepisBod
```
public void prepisBod(double x,
                      double y,
                      Farebnosť objekt)
```
    Alias pre prepíšBod.
  - prepisBod
```
public void prepisBod(double x,
                      double y,
                      int farba)
```
    Alias pre prepíšBod.
  - prepíšBod
```
public void prepíšBod(Poloha bod,
                      Color farba)
```
    Prepíše farebné zložky a zložku priehľadnosti na pozícii zadaného bodu zadanou farbou.
    
    Parametre:
    
    bod – objekt reprezentujúci súradnice bodu (v súradnicovom priestore robota)
    
    farba – objekt určujúci novú farbu bodu
  - prepíšBod
```
public void prepíšBod(Poloha bod,
                      Farebnosť objekt)
```
    Prepíše farebné zložky a zložku priehľadnosti na pozícii zadaného bodu farbou zadaného objektu.
    
    Parametre:
    
    bod – objekt reprezentujúci súradnice bodu (v súradnicovom priestore robota)
    
    objekt – objekt určujúci novú farbu bodu
  - prepíšBod
```
public void prepíšBod(Poloha bod,
                      int farba)
```
    Prepíše farebné zložky a zložku priehľadnosti na pozícii zadaného bodu zadanou kombináciou zložiek ARGB zakódovaných v celočíselnej hodnote.
    
    Parametre:
    
    bod – objekt reprezentujúci súradnice bodu (v súradnicovom priestore robota)
    
    farba – celé číslo obsahujúce kombináciu farebných zložiek RGB a priehľadnosti
  - prepisBod
```
public void prepisBod(Poloha bod,
                      Color farba)
```
    Alias pre prepíšBod.
  - prepisBod
```
public void prepisBod(Poloha bod,
                      Farebnosť objekt)
```
    Alias pre prepíšBod.
  - prepisBod
```
public void prepisBod(Poloha bod,
                      int farba)
```
    Alias pre prepíšBod.
  - kreslič
```
public GRobot kreslič()
```
    Vráti aktuálneho kresliča obrázka alebo null, ak nie je kreslič nastavený. Pre podrobnosti pozri informácie pri setteri vlastnosti kreslič.
    
    Návratová hodnota:
    
    grafický robot zvolený za kresliča alebo null, ak obrázok nemá nastaveného žiadneho konkrétneho kresliča
  - kreslic
```
public GRobot kreslic()
```
    Alias pre kreslič.
  - kreslič
```
public void kreslič(GRobot kreslič)
```
    Nastaví „kresliča“ obrázka – grafického robota, ktorý bude slúžiť na alternatívne kreslenie a vypĺňanie tvarov v rámci obrázka. Vlastnosť je určená na kombinované fungovanie s metódami kresli a vyplň. (Tie sú v súčasnosti považované za metódy, ktoré poskytujú alternatívny spôsob kreslenia a vypĺňania tvarov do obrázka. Podrobnosti nájdete v ich opisoch.) Novému zvolenému kresličovi bude automaticky vypnuté kreslenie tvarov, pričom jeho štandardné kresliace schopnosti (kreslenie pri pohybe dopredu, dozadu a podobne, pri položenom pere) zostávajú zachované. Prípadnému starému kresličovi bude kreslenie tvarov automaticky zapnuté.
    
    Táto vlastnosť je určená výhradne na použitie s metódami kresli a vyplň, ktoré očakávajú výstupy z metód robota na kreslenie tvarov (kruh, elipsa, štvorec a podobne). Nie je dobré túto vlastnosť kombinovať s úplným presmerovaním kreslenia robota do obrázka. Mohli by sme získať neočakávané výsledky.
    
    Keď chceme kresliča zrušiť, pošleme do argumentu tejto metódy hodnotu null alebo použijeme metódu zrušKresliča.
    
    Parametre:
    
    kreslič – nový kreslič (grafický robot) alebo null
  - kreslic
```
public void kreslic(GRobot kreslič)
```
    Alias pre kreslič.
  - zrušKresliča
```
public void zrušKresliča()
```
    Zruší kresliča obrázka. Pre podrobnosti pozri informácie pri setteri vlastnosti kreslič – volanie tejto metódy má rovnaký efekt ako spustenie metódy kreslič s hodnotou argumentu null.
  - zrusKreslica
```
public void zrusKreslica()
```
    Alias pre zrušKresliča.
  - kresli
```
public void kresli(Shape tvar)
```
    Táto metóda slúži na kreslenie obrysov zadaného tvaru do obrázka. Ak má tento objekt obrázka nastaveného takzvaného kresliča, tak táto metóda použije na nakreslenie jeho farbu alebo náter a štýl čiary. V opačnom prípade použije hlavný robot.
    
    Zadaný tvar by mal byť vygenerovaný niektorým robotom (metódami na kreslenie tvarov), pretože obrázky majú súradnicový priestor prispôsobený prostrediu rámca – osi sú posunuté tak, aby robot v pozícii [0, 0] kreslil do stredu obrázka (toto posunutie závisí nielen od rozmerov obrázka, ale aj od aktuálnych rozmerov plátien) a y-ová súradnica je orientovaná podľa súradnicového systému Javy, to znamená, že je voči svetu robota zrkadlovo prevrátená. (O súradnicových priestoroch sa podrobnejšie píše napríklad v opisoch metód GRobot.cesta(), SVGpodpora.zapíš(…), SVGpodpora.čítaj(meno) a priebežne v celej dokumentácii.)
    
    Tip: V súvislosti s generovaním tvarov a ich použitím by robot, ktorého chceme použiť na generovanie tvarov, mal mať vypnuté kreslenie tvarov, aby vygenerovaný tvar nenakreslil do aktívneho plátna, prípadne do iného obrázka, do ktorého má presmerované kreslenie. Automatické vypnutie alebo zapnutie kreslenia tvarov zvoleného grafického robota vykoná metóda kreslič a to podľa toho, či je jej argumentom konkrétny robot – vtedy mu kreslenie tvarov vypne, alebo hodnota null – vtedy zapne kreslenie tvarov tomu robotu, ktorý bol aktuálnym kresličom konkrétneho obrázka. Metóda však nezaznamenáva počet spustení pre roboty, takže v prípade jej náhodného spúšťania s rôznymi hodnotami argumentov – robotov alebo hodnôt null, je výsledný stav kreslenia alebo nekreslenia tvarov pre konkrétny robot rovný tomu stavu, do ktorého ho preplo posledné spustenie dotknutej metódy. Treba si na to dať pozor v prípade, že chceme ten istý robot použiť ako kresliča viacerých obrázkov.
    
    Na kreslenie robotom do obrázka je jednoduchšie je použiť metódu GRobot.kresliNaObrázok(Obrázok) na presmerovanie kreslenia robota do obrázka a kresliť robotom rovnakým spôsobom ako pri klasickom kreslení na plátno (podlahu alebo strop).
    
    Parametre:
    
    tvar – objekt typu Shape, ktorý bude nakreslený aktuálnym štýlom čiary a farbou/náterom kresliča alebo hlavného robota
    
    Pozri tiež:
    
    vyplň(Shape), kresli(Shape, GRobot), vyplň(Shape, GRobot)
  - kresli
```
public void kresli(Shape tvar,
                   GRobot kreslič)
```
    Táto metóda slúži na kreslenie obrysov zadaného tvaru do obrázka. Metóda potrebuje na svoje správne fungovanie zadanie robota „kresliča,“ ktorého farbu alebo náter a štýl čiary použije na kreslenie. Ak je do metódy namiesto konkrétneho kresliča zadaná hodnota null, tak je na získanie parametrov kreslenia použitý hlavný robot (ak ten nejestvuje, kreslenie nebude vykonané).
    
    Parametre:
    
    tvar – objekt typu Shape, ktorý bude nakreslený aktuálnym štýlom čiary a farbou/náterom zadaného robota („kresliča“)
    
    kreslič – grafický robot, ktorého parametre budú použité na kreslenie alebo null
    
    Pozri tiež:
    
    vyplň(Shape, GRobot), kresli(Shape), vyplň(Shape)
  - vyplň
```
public void vyplň(Shape tvar)
```
    Táto metóda slúži na kreslenie vyplnených tvarov do obrázka. Ak má tento objekt obrázka nastaveného takzvaného kresliča, tak táto metóda použije na vyplnenie jeho farbu alebo náter. V opačnom prípade použije hlavný robot (ak ten nejestvuje, kreslenie nebude vykonané).
    
    Zadaný tvar by mal byť vygenerovaný niektorým robotom (metódami na kreslenie tvarov), pretože obrázky majú súradnicový priestor prispôsobený prostrediu rámca – osi sú posunuté tak, aby robot v pozícii [0, 0] kreslil do stredu obrázka (toto posunutie závisí nielen od rozmerov obrázka, ale aj od aktuálnych rozmerov plátien) a y-ová súradnica je orientovaná podľa súradnicového systému Javy, to znamená, že je voči svetu robota zrkadlovo prevrátená. (O súradnicových priestoroch sa podrobnejšie píše napríklad v opisoch metód GRobot.cesta(), SVGpodpora.zapíš(…), SVGpodpora.čítaj(meno) a priebežne v celej dokumentácii.)
    
    Tip: V súvislosti s generovaním tvarov a ich použitím by robot, ktorého chceme použiť na generovanie tvarov, mal mať vypnuté kreslenie tvarov, aby vygenerovaný tvar nenakreslil do aktívneho plátna, prípadne do iného obrázka, do ktorého má presmerované kreslenie. Automatické vypnutie alebo zapnutie kreslenia tvarov zvoleného grafického robota vykoná metóda kreslič a to podľa toho, či je jej argumentom konkrétny robot – vtedy mu kreslenie tvarov vypne, alebo hodnota null – vtedy zapne kreslenie tvarov tomu robotu, ktorý bol aktuálnym kresličom konkrétneho obrázka. Metóda však nezaznamenáva počet spustení pre roboty, takže v prípade jej náhodného spúšťania s rôznymi hodnotami argumentov – robotov alebo hodnôt null, je výsledný stav kreslenia alebo nekreslenia tvarov pre konkrétny robot rovný tomu stavu, do ktorého ho preplo posledné spustenie dotknutej metódy. Treba si na to dať pozor v prípade, že chceme ten istý robot použiť ako kresliča viacerých obrázkov.
    
    Na kreslenie robotom do obrázka je jednoduchšie je použiť metódu GRobot.kresliNaObrázok(Obrázok) na presmerovanie kreslenia robota do obrázka a kresliť robotom rovnakým spôsobom ako pri klasickom kreslení na plátno (podlahu alebo strop).
    
    Parametre:
    
    tvar – objekt typu Shape, ktorý bude vyplnený aktuálnou farbou/náterom kresliča alebo hlavného robota
    
    Pozri tiež:
    
    kresli(Shape), vyplň(Shape, GRobot), kresli(Shape, GRobot)
  - vypln
```
public void vypln(Shape tvar)
```
    Alias pre vyplň.
  - vyplň
```
public void vyplň(Shape tvar,
                  GRobot kreslič)
```
    Táto metóda slúži na kreslenie vyplnených tvarov do obrázka. Metóda potrebuje na svoje správne fungovanie zadanie robota „kresliča,“ ktorého farbu alebo náter použije na vyplnenie zadaného tvaru. Ak je do metódy namiesto konkrétneho kresliča zadaná hodnota null, tak je na získanie parametrov kreslenia použitý hlavný robot (ak ten nejestvuje, kreslenie nebude vykonané).
    
    Parametre:
    
    tvar – objekt typu Shape, ktorý bude vyplnený aktuálnou farbou/náterom zadaného robota („kresliča“)
    
    kreslič – grafický robot, ktorého parametre budú použité na kreslenie alebo null
    
    Pozri tiež:
    
    kresli(Shape, GRobot), vyplň(Shape), kresli(Shape)
  - vypln
```
public void vypln(Shape tvar,
                  GRobot kreslič)
```
    Alias pre vyplň.
  - vyplň
```
public void vyplň(Color farba)
```
    Vyplní celú plochu obrázka zadanou farbou.
    
    Parametre:
    
    farba – objekt určujúci farbu na výplň plátna
    
    Pozri tiež:
    
    vymaž()
  - vypln
```
public void vypln(Color farba)
```
    Alias pre vyplň.
  - vyplň
```
public void vyplň(Farebnosť objekt)
```
    Vyplní celú plochu obrázka farbou zadaného objektu.
    
    Parametre:
    
    objekt – objekt určujúci farbu na výplň plátna
    
    Pozri tiež:
    
    vymaž()
  - vypln
```
public void vypln(Farebnosť objekt)
```
    Alias pre vyplň.
  - vyplň
```
public Farba vyplň(int r,
                   int g,
                   int b)
```
    Vyplní obrázok farbou zadanou prostredníctvom farebných zložiek.
    
    Parametre:
    
    r – červená zložka farby; celé číslo v rozsahu 0 – 255
    
    g – zelená zložka farby; celé číslo v rozsahu 0 – 255
    
    b – modrá zložka farby; celé číslo v rozsahu 0 – 255
    
    Návratová hodnota:
    
    objekt typu Farba vytvorený podľa zadaných zložiek
    
    Pozri tiež:
    
    vyplň(Color)
  - vypln
```
public Farba vypln(int r,
                   int g,
                   int b)
```
    Alias pre vyplň.
  - vyplň
```
public Farba vyplň(int r,
                   int g,
                   int b,
                   int a)
```
    Vyplní obrázok farbou zadanou prostredníctvom farebných zložiek a úrovne (ne)priehľadnosti.
    
    Parametre:
    
    r – červená zložka farby; celé číslo v rozsahu 0 – 255
    
    g – zelená zložka farby; celé číslo v rozsahu 0 – 255
    
    b – modrá zložka farby; celé číslo v rozsahu 0 – 255
    
    a – úroveň (ne)priehľadnosti farby; celé číslo v rozsahu 0 – 255 (0 – neviditeľná farba; 255 – nepriehľadná farba)
    
    Návratová hodnota:
    
    objekt typu Farba vytvorený podľa zadaných hodnôt parametrov
    
    Pozri tiež:
    
    vyplň(Color)
  - vypln
```
public Farba vypln(int r,
                   int g,
                   int b,
                   int a)
```
    Alias pre vyplň.
  - vyplň
```
public void vyplň(Shape tvar,
                  String súbor)
```
    Vyplní zadaný tvar textúrou prečítanou zo súboru s obrázkom a výsledok nakreslí do obrázka.
    
    Zadaný tvar by mal byť generovaný niektorým robotom (metódami na kreslenie tvarov), pretože obrázky majú súradnicový priestor prispôsobený prostrediu rámca. Zvolený grafický robot by mal mať vypnuté kreslenie tvarov, aby vygenerovaný tvar nenakreslil do aktívneho plátna (prípadne do obrázka, do ktorého bolo jeho kreslenie presmerované).
    
    Obrázok prečítaný zo súboru je chápaný ako zdroj a po prečítaní zostane uložený vo vnútornej pamäti sveta. Z nej môže byť v prípade potreby (napríklad ak sa obsah súboru na disku zmenil) odstránený metódou Svet.uvoľni(názovZdroja). (Táto informácia je platná pre všetky metódy pracujúce s obrázkami alebo zvukmi, ktoré prijímajú názov súboru ako parameter.)
    
    Poznámka: Parametre textúry sa dajú ovplyvňovať špeciálnymi príkazmi. Súvisí s nimi i predvolené správanie príkazov vypĺňania. Predvolený bod začiatku vypĺňania dlaždicami sa nachádza v strede plátna alebo vypĺňaného obrázka. Pozrite si aj opis metódy posunutieVýplne, kde nájdete príklad použitia a odkazy na metódy upravujúce ďalšie parametre obrázkových výplní.
    
    Parametre:
    
    tvar – objekt typu Shape, ktorý bude vyplnený textúrou
    
    súbor – názov súboru s obrázkom textúry
    
    Výnimky:
    
    GRobotException – ak súbor s obrázkom nebol nájdený (identifikátor imageNotFound)
    
    Pozri tiež:
    
    Svet.priečinokObrázkov(String)
  - vypln
```
public void vypln(Shape tvar,
                  String súbor)
```
    Alias pre vypln.
  - vyplň
```
public void vyplň(Shape tvar,
                  Image výplň)
```
    Vyplní zadaný tvar textúrou určenou zadaným obrázkom a výsledok nakreslí do tohto obrázka. Ako textúra by nemal byť použitý ten obrázok, do ktorého je vypĺňaný tvar kreslený.
    
    Zadaný tvar by mal byť generovaný niektorým robotom (metódami na kreslenie tvarov), pretože obrázky majú súradnicový priestor prispôsobený prostrediu rámca. Zvolený grafický robot by mal mať vypnuté kreslenie tvarov, aby vygenerovaný tvar nenakreslil do aktívneho plátna (prípadne do obrázka, do ktorého bolo jeho kreslenie presmerované).
    
    Poznámka: Parametre textúry sa dajú ovplyvňovať špeciálnymi príkazmi. Súvisí s nimi i predvolené správanie príkazov vypĺňania. Predvolený bod začiatku vypĺňania dlaždicami sa nachádza v strede plátna alebo vypĺňaného obrázka. Pozrite si aj opis metódy posunutieVýplne, kde nájdete príklad použitia a odkazy na metódy upravujúce ďalšie parametre obrázkových výplní.
    
    Parametre:
    
    tvar – objekt typu Shape, ktorý bude vyplnený textúrou
    
    výplň – obrázok s textúrou
  - vypln
```
public void vypln(Shape tvar,
                  Image výplň)
```
    Alias pre vypln.
  - kresli
```
public void kresli(String súbor)
```
    Nakreslí do stredu tohto obrázka obrázok zo zadaného súboru.
    
    Obrázok prečítaný zo súboru je chápaný ako zdroj a po prečítaní zostane uložený vo vnútornej pamäti sveta. Z nej môže byť v prípade potreby (napríklad ak sa obsah súboru na disku zmenil) odstránený metódou Svet.uvoľni(názovZdroja). (Táto informácia je platná pre všetky metódy pracujúce s obrázkami alebo zvukmi, ktoré prijímajú názov súboru ako parameter.)
    
    Parametre:
    
    súbor – názov súboru s obrázkom
    
    Pozri tiež:
    
    Svet.priečinokObrázkov(String)
  - kresli
```
public void kresli(double x,
                   double y,
                   String súbor)
```
    Nakreslí do tohto obrázka obrázok zo zadaného súboru, ktorý bude posunutý od stredu o zadané súradnice v horizontálnom a vertikálnom smere.
    
    Obrázok prečítaný zo súboru je chápaný ako zdroj a po prečítaní zostane uložený vo vnútornej pamäti sveta. Z nej môže byť v prípade potreby (napríklad ak sa obsah súboru na disku zmenil) odstránený metódou Svet.uvoľni(názovZdroja). (Táto informácia je platná pre všetky metódy pracujúce s obrázkami alebo zvukmi, ktoré prijímajú názov súboru ako parameter.)
    
    Parametre:
    
    x – posun od stredu v horizontálnom smere
    
    y – posun od stredu vo vertikálnom smere
    
    súbor – názov súboru s obrázkom
    
    Pozri tiež:
    
    Svet.priečinokObrázkov(String)
  - kresli
```
public void kresli(Poloha objekt,
                   String súbor)
```
    Nakreslí do tohto obrázka obrázok zo zadaného súboru, obrázok bude posunutý o súradnice určené polohou zadaného objektu.
    
    Parametre:
    
    objekt – objekt, ktorého súradnice určia posunutie obrázka
    
    súbor – názov súboru s obrázkom
    
    Pozri tiež:
    
    Svet.priečinokObrázkov(String)
  - kresli
```
public void kresli(Image obrázok)
```
    Nakreslí do stredu tohto obrázka zadaný obrázok.
    
    Parametre:
    
    obrázok – obrázok, ktorý má byť nakreslený
  - kresli
```
public void kresli(double x,
                   double y,
                   Image obrázok)
```
    Nakreslí do tohto obrázka zadaný obrázok, pričom ho posunie od stredu o zadané súradnice v horizontálnom a vertikálnom smere.
    
    Parametre:
    
    x – posun od stredu v horizontálnom smere
    
    y – posun od stredu vo vertikálnom smere
    
    obrázok – obrázok, ktorý má byť nakreslený
  - kresli
```
public void kresli(Poloha objekt,
                   Image obrázok)
```
    Nakreslí do tohto obrázka zadaný obrázok, obrázok bude posunutý o súradnice určené polohou zadaného objektu.
    
    Parametre:
    
    objekt – objekt, ktorého súradnice určia posunutie obrázka
    
    obrázok – obrázok, ktorý má byť nakreslený
  - vyplň
```
public void vyplň(String súbor)
```
    Vyplní obrázok zadanou textúrou. Textúra je súbor s obrázkom, ktorý bude použitý na dlaždicové vyplnenie celej plochy tohto obrázka.
    
    Obrázok prečítaný zo súboru je chápaný ako zdroj a po prečítaní zostane uložený vo vnútornej pamäti sveta. Z nej môže byť v prípade potreby (napríklad ak sa obsah súboru na disku zmenil) odstránený metódou Svet.uvoľni(názovZdroja). (Táto informácia je platná pre všetky metódy pracujúce s obrázkami alebo zvukmi, ktoré prijímajú názov súboru ako parameter.)
    
    Poznámka: Parametre textúry sa dajú ovplyvňovať špeciálnymi príkazmi. Súvisí s nimi i predvolené správanie príkazov vypĺňania. Predvolený bod začiatku vypĺňania dlaždicami sa nachádza v strede plátna alebo vypĺňaného obrázka. Pozrite si aj opis metódy posunutieVýplne, kde nájdete príklad použitia a odkazy na metódy upravujúce ďalšie parametre obrázkových výplní.
    
    Parametre:
    
    súbor – názov súboru s obrázkom textúry
    
    Výnimky:
    
    GRobotException – ak súbor s obrázkom nebol nájdený (identifikátor imageNotFound)
    
    Pozri tiež:
    
    vyplň(Color), Svet.priečinokObrázkov(String)
  - vypln
```
public void vypln(String súbor)
```
    Alias pre vyplň.
  - vyplň
```
public void vyplň(Image výplň)
```
    Vyplní obrázok zadanou textúrou. Textúra je iný obrázok (objekt typu Image alebo odvodený), ktorý bude použitý na dlaždicové vyplnenie celej plochy tohto obrázka.
    
    Poznámka: Parametre textúry sa dajú ovplyvňovať špeciálnymi príkazmi. Súvisí s nimi i predvolené správanie príkazov vypĺňania. Predvolený bod začiatku vypĺňania dlaždicami sa nachádza v strede plátna alebo vypĺňaného obrázka. Pozrite si aj opis metódy posunutieVýplne, kde nájdete príklad použitia a odkazy na metódy upravujúce ďalšie parametre obrázkových výplní.
    
    Parametre:
    
    výplň – obrázok s textúrou
    
    Pozri tiež:
    
    vyplň(Color)
  - vypln
```
public void vypln(Image výplň)
```
    Alias pre vyplň.
  - vylejFarbu
```
public void vylejFarbu(double x,
                       double y,
                       Color farba)
```
    Vyleje do zadaného bodu do obrázka farbu, ktorá sa odtiaľ rozšíri po okraje tej časti kresby v obrázku, v ktorej sa zadaný bod nachádza. Na ďalšie informácie pozri metódu Plátno.vylejFarbu(double, double, Color). Správanie tejto metódy je jej veľmi podobné.
    
    Parametre:
    
    x – x-ová súradnica počiatočného bodu
    
    y – y-ová súradnica počiatočného bodu
    
    farba – objekt určujúci farbu výplne
  - vylejFarbu
```
public void vylejFarbu(double x,
                       double y,
                       Farebnosť objekt)
```
    Vyleje do zadaného bodu do obrázka farbu (určenú objektom), ktorá sa odtiaľ rozšíri po okraje tej časti kresby v obrázku, v ktorej sa zadaný bod nachádza. Na ďalšie informácie pozri metódu Plátno.vylejFarbu(double, double, Color). Správanie tejto metódy je jej veľmi podobné.
    
    Parametre:
    
    x – x-ová súradnica počiatočného bodu
    
    y – y-ová súradnica počiatočného bodu
    
    objekt – objekt určujúci farbu výplne
  - vylejFarbu
```
public Farba vylejFarbu(double x,
                        double y,
                        int r,
                        int g,
                        int b)
```
    Vyleje do zadaného bodu do obrázka farbu zadanú prostredníctvom farebných zložiek, ktorá sa určeného bodu rozšíri po okraje okolitej kresby. Na ďalšie informácie pozri metódu vylejFarbu(double x, double y, Color farba). Správanie tejto metódy je odvodené od nej.
    
    Parametre:
    
    x – x-ová súradnica počiatočného bodu
    
    y – y-ová súradnica počiatočného bodu
    
    r – červená zložka farby; celé číslo v rozsahu 0 – 255
    
    g – zelená zložka farby; celé číslo v rozsahu 0 – 255
    
    b – modrá zložka farby; celé číslo v rozsahu 0 – 255
    
    Návratová hodnota:
    
    objekt typu Farba vytvorený podľa zadaných zložiek
    
    Pozri tiež:
    
    vylejFarbu(double, double, Color)
  - vylejFarbu
```
public Farba vylejFarbu(double x,
                        double y,
                        int r,
                        int g,
                        int b,
                        int a)
```
    Vyleje do zadaného bodu do obrázka farbu zadanú prostredníctvom farebných zložiek a úrovne (ne)priehľadnosti, pričom farba sa z určeného bodu rozšíri k okrajom okolitej kresby. Na ďalšie informácie pozri metódu vylejFarbu(double x, double y, Color farba). Správanie tejto metódy je odvodené od nej.
    
    Parametre:
    
    x – x-ová súradnica počiatočného bodu
    
    y – y-ová súradnica počiatočného bodu
    
    r – červená zložka farby; celé číslo v rozsahu 0 – 255
    
    g – zelená zložka farby; celé číslo v rozsahu 0 – 255
    
    b – modrá zložka farby; celé číslo v rozsahu 0 – 255
    
    a – úroveň (ne)priehľadnosti farby; celé číslo v rozsahu 0 – 255 (0 – neviditeľná farba; 255 – nepriehľadná farba)
    
    Návratová hodnota:
    
    objekt typu Farba vytvorený podľa zadaných hodnôt parametrov
    
    Pozri tiež:
    
    vylejFarbu(double, double, Color)
  - vylejFarbu
```
public void vylejFarbu(Poloha bod,
                       Color farba)
```
    Vyleje do zadaného bodu do obrázka farbu, ktorá sa odtiaľ rozšíri po okraje tej časti kresby v obrázku, v ktorej sa zadaný bod nachádza. Na ďalšie informácie pozri metódu Plátno.vylejFarbu(double, double, Color). Správanie tejto metódy je jej veľmi podobné.
    
    Parametre:
    
    bod – súradnice počiatočného bodu
    
    farba – objekt určujúci farbu výplne
  - vylejFarbu
```
public void vylejFarbu(Poloha bod,
                       Farebnosť objekt)
```
    Vyleje do zadaného bodu do obrázka farbu (určenú objektom), ktorá sa odtiaľ rozšíri po okraje tej časti kresby v obrázku, v ktorej sa zadaný bod nachádza. Na ďalšie informácie pozri metódu Plátno.vylejFarbu(double, double, Color). Správanie tejto metódy je jej veľmi podobné.
    
    Parametre:
    
    bod – súradnice počiatočného bodu
    
    objekt – objekt určujúci farbu výplne
  - vylejFarbu
```
public Farba vylejFarbu(Poloha bod,
                        int r,
                        int g,
                        int b)
```
    Vyleje do zadaného bodu do obrázka farbu zadanú prostredníctvom farebných zložiek, ktorá sa určeného bodu rozšíri po okraje okolitej kresby. Na ďalšie informácie pozri metódu vylejFarbu(double x, double y, Color farba). Správanie tejto metódy je odvodené od nej.
    
    Parametre:
    
    bod – súradnice počiatočného bodu
    
    r – červená zložka farby; celé číslo v rozsahu 0 – 255
    
    g – zelená zložka farby; celé číslo v rozsahu 0 – 255
    
    b – modrá zložka farby; celé číslo v rozsahu 0 – 255
    
    Návratová hodnota:
    
    objekt typu Farba vytvorený podľa zadaných zložiek
    
    Pozri tiež:
    
    vylejFarbu(Poloha, Color)
  - vylejFarbu
```
public Farba vylejFarbu(Poloha bod,
                        int r,
                        int g,
                        int b,
                        int a)
```
    Vyleje do zadaného bodu do obrázka farbu zadanú prostredníctvom farebných zložiek a úrovne (ne)priehľadnosti, pričom farba sa z určeného bodu rozšíri k okrajom okolitej kresby. Na ďalšie informácie pozri metódu vylejFarbu(double x, double y, Color farba). Správanie tejto metódy je odvodené od nej.
    
    Parametre:
    
    bod – súradnice počiatočného bodu
    
    r – červená zložka farby; celé číslo v rozsahu 0 – 255
    
    g – zelená zložka farby; celé číslo v rozsahu 0 – 255
    
    b – modrá zložka farby; celé číslo v rozsahu 0 – 255
    
    a – úroveň (ne)priehľadnosti farby; celé číslo v rozsahu 0 – 255 (0 – neviditeľná farba; 255 – nepriehľadná farba)
    
    Návratová hodnota:
    
    objekt typu Farba vytvorený podľa zadaných hodnôt parametrov
    
    Pozri tiež:
    
    vylejFarbu(Poloha, Color)
  - vylejFarbu
```
public void vylejFarbu(GRobot ktorý)
```
    Zadaný robot vyleje na svojej pozícii do obrázka svoju aktuálnu farbu, ktorá sa odtiaľ rozšíri po okraje okolitej kresby. Na ďalšie informácie pozri metódu vylejFarbu(double x, double y, Color farba). Správanie tejto metódy je odvodené od nej.
    
    Parametre:
    
    ktorý – robot, ktorého poloha a farba sú použité na výplň
  - negatív
```
public void negatív()
```
    Pretvorí tento obrázok na svoj farebný negatív.
  - negativ
```
public void negativ()
```
    Alias pre negatív.
  - bledší
```
public void bledší(double faktor)
```
    Zvýši úroveň svetlosti tohto obrázka. Metóda používa rovnaký spôsob zosvetlenia ako metóda Farba.svetlejšia(double).
    
    Poznámka: Metóda zachováva aj kanál priehľadnosti obrázka.
    
    Parametre:
    
    faktor – faktor zosvetlenia – hodnota v rozsahu 0.0 – 1.0, pričom krajné hodnoty (0.0 a 1.0) nie sú povolené; čím je hodnota faktora nižšia, tým je zmena svetlosti výraznejšia
    
    Pozri tiež:
    
    tmavší(double)
  - bledsi
```
public void bledsi(double faktor)
```
    Alias pre bledší.
  - svetlejší
```
public void svetlejší(double faktor)
```
    Alias pre bledší.
  - svetlejsi
```
public void svetlejsi(double faktor)
```
    Alias pre bledší.
  - tmavší
```
public void tmavší(double faktor)
```
    Zníži úroveň svetlosti tohto obrázka. Metóda používa rovnaký spôsob stmavenia ako metóda Farba.tmavšia(double).
    
    Poznámka: Metóda zachováva aj kanál priehľadnosti obrázka.
    
    Parametre:
    
    faktor – faktor stmavenia – hodnota v rozsahu 0.0 – 1.0, pričom krajné hodnoty (0.0 a 1.0) nie sú na použitie vhodné (0.0 by stmavila farbu do čiernej a 1.0 by nevykonala žiadnu zmenu svetlosti); čím je hodnota faktora nižšia, tým je úroveň stmavenia výraznejšia
    
    Pozri tiež:
    
    bledší(double)
  - tmavsi
```
public void tmavsi(double faktor)
```
    Alias pre tmavší.
  - bledší
```
public void bledší()
```
    Zvýši úroveň svetlosti tohto obrázka. Metóda používa rovnaký spôsob zosvetlenia ako metóda Farba.svetlejšia().
    
    Poznámka: Metóda zachováva aj kanál priehľadnosti obrázka.
    
    Poznámka: Metóda používa predvolenú hodnotu faktora zosvetlenia 0.7. Pozri aj bledší(faktor).
    
    Pozri tiež:
    
    tmavší()
  - bledsi
```
public void bledsi()
```
    Alias pre bledší.
  - svetlejší
```
public void svetlejší()
```
    Alias pre bledší.
  - svetlejsi
```
public void svetlejsi()
```
    Alias pre bledší.
  - tmavší
```
public void tmavší()
```
    Zníži úroveň svetlosti tohto obrázka. Metóda používa rovnaký spôsob stmavenia ako metóda Farba.tmavšia().
    
    Poznámka: Metóda zachováva aj kanál priehľadnosti obrázka.
    
    Poznámka: Metóda používa predvolenú hodnotu faktora stmavenia 0.7. Pozri aj tmavší(faktor).
    
    Pozri tiež:
    
    bledší()
  - tmavsi
```
public void tmavsi()
```
    Alias pre tmavší.
  - čiernobiely
```
public void čiernobiely()
```
    Upraví tento obrázok do odtieňov šedej s použitím priemerovania farebných zložiek. Je to rýchla metóda, ale výsledné odtiene nie sú v súlade s modelom ľudského vnímania farieb. Pozri aj čiernobiely(vyvážiťZložky).
    
    Porovnanie rôznych metód prevodu do odtieňov šedej je v opise metódy čiernobiely(vyvážiťZložky).
    
    Poznámka: Metóda zachováva aj kanál priehľadnosti obrázka.
    
    Pozri tiež:
    
    čiernobiely(boolean), čiernobiely(double, double, double), monochromatický(Color), farebnýFilter(Color), farebnéTienidlo(Color)
  - ciernobiely
```
public void ciernobiely()
```
    Alias pre čiernobiely.
  - odtieneŠedej
```
public void odtieneŠedej()
```
    Alias pre čiernobiely.
  - odtieneSedej
```
public void odtieneSedej()
```
    Alias pre čiernobiely.
  - čiernobiely
```
public void čiernobiely(boolean vyvážiťZložky)
```
    Upraví tento obrázok do odtieňov šedej s možnosťou určenia predvoleného vyváženia farebných zložiek – podľa modelu ľudského vnímania farieb.
    
    Ak je parameter vyvážiťZložky rovný true, tak bude použité predvolené vyváženie zložiek, inak bude použité priemerovanie, rovnako ako pri metóde čiernobiely().
    
    Predvolené hodnoty vyváženia sú nasledujúce: 29,9 % červenej, 58,7 % zelenej a 11,4 % modrej. Ak chcete použiť vlastné váhy, tak použite metódu čiernobiely(váhaČervenej, váhaZelenej, váhaModrej).
    
    Porovnanie rôznych metód prevodu do odtieňov šedej.
    
    Obrázok vyššie porovnáva rôzne metódy prevodu obrázka do odtieňov šedej. Vľavo hore je pôvodný farebný obrázok, vedľa neho je obrázok prevedený metódou čiernobiely() (priemerovanie zložiek), vľavo dole je verzia prevedená pomocou tejto metódy s parametrom vyvážiťZložky rovným true a vpravo dole je použitá metóda čiernobiely(váhaČervenej, váhaZelenej, váhaModrej) s váhami nastavenými na hodnoty: 0.0 (červená), 0.3 (zelená) a 0.5 (modrá). To znamená, že pôvodná červená zložka je z odtieňov elimiovaná a súčet zostávajúcich dvoch nie je rovný 100 % (0,3 = 30 %; 0,5 = 50 %; čo je dohromady len 80 %). Z toho je jasné, že výsledok bude tmavší. Obrázok vpravo dole skutočne pôsobí akoby bol snímaný v odlišnom spektre elektromagnetického vlnenia (čo je, samozrejme, falošný dojem, pretože chýbajúcu informáciu nemôžeme od obrazu doplniť žiadnym prevodom, ale môžeme aspoň nasimulovať taký efekt).
    
    Poznámka: Metóda zachováva aj kanál priehľadnosti obrázka.
    
    Obrázok nižšie ukazuje porovnanie metódy priemerovania a automatického vyváženia zložiek na staršej verzii predvolenej palety preddefinovaných farieb.
    
    a) predvolená paleta
    
    b) použitie metódy priemerovania
    
    c) použitie metódy vyváženia zložiek
    
    Porovnanie rôznych metód prevodu do odtieňov šedej.
    
    Použitý zdroj:
    - Francis G. Loch: Image Processing Algorithms Part 3: Greyscale Conversion. Dreamland Fantasy Studios, 2008, 2010. Citované: 2018.
    Parametre:
    
    vyvážiťZložky – pravdivostná hodnota určujúca, či majú byť odtiene vypočítané algoritmom vyvažovania farebných zložiek
    
    Pozri tiež:
    
    čiernobiely(), čiernobiely(double, double, double), monochromatický(Color), farebnýFilter(Color), farebnéTienidlo(Color)
  - ciernobiely
```
public void ciernobiely(boolean vyvážiťZložky)
```
    Alias pre čiernobiely.
  - odtieneŠedej
```
public void odtieneŠedej(boolean vyvážiťZložky)
```
    Alias pre čiernobiely.
  - odtieneSedej
```
public void odtieneSedej(boolean vyvážiťZložky)
```
    Alias pre čiernobiely.
  - čiernobiely
```
public void čiernobiely(double váhaČervenej,
                        double váhaZelenej,
                        double váhaModrej)
```
    Upraví tento obrázok do odtieňov šedej s možnosťou určenia vlastného vyváženia jednotlivých farebných zložiek. Táto metóda umožňuje úplne odfiltrovať alebo preexponovať niektorú farebnú zložku.
    
    Porovnanie rôznych metód prevodu do odtieňov šedej je v opise metódy čiernobiely(vyvážiťZložky).
    
    Poznámka: Metóda zachováva aj kanál priehľadnosti obrázka.
    
    Parametre:
    
    váhaČervenej – hodnota určujúca mieru vyváženia červenej farebnej zložky
    
    váhaZelenej – hodnota určujúca mieru vyváženia zelenej farebnej zložky
    
    váhaModrej – hodnota určujúca mieru vyváženia modrej farebnej zložky
    
    Pozri tiež:
    
    čiernobiely(), čiernobiely(boolean), monochromatický(Color), farebnýFilter(Color), farebnéTienidlo(Color)
  - ciernobiely
```
public void ciernobiely(double váhaČervenej,
                        double váhaZelenej,
                        double váhaModrej)
```
    Alias pre čiernobiely.
  - odtieneŠedej
```
public void odtieneŠedej(double váhaČervenej,
                         double váhaZelenej,
                         double váhaModrej)
```
    Alias pre čiernobiely.
  - odtieneSedej
```
public void odtieneSedej(double váhaČervenej,
                         double váhaZelenej,
                         double váhaModrej)
```
    Alias pre čiernobiely.
  - monochromatický
```
public void monochromatický(Color farba)
```
    Upraví tento obrázok do odtieňov zadanej farby. Monochromatická zložka, čiže zložka jasu (odtiene šedej), bude násobená farebnými zložkami zadanej farby. Výsledkom bude obrázok v odtieňoch zadanej farby. Ak zadáme čiernu farbu, získame čierny obrázok. Ak zadáme bielu, dostaneme čiernobiely obrázok. Ľubovoľná iná farba zafarbí obrázok do jej odtieňov.
    
    Porovnanie rôznych efektov použitých na rovnaký obrázok je v opise metódy farebnéTienidlo(farba).
    
    Poznámka: Metóda zachováva aj kanál priehľadnosti obrázka.
    
    Parametre:
    
    farba – farba, do odtieňov ktorej bude obrázok prevedený
    
    Pozri tiež:
    
    čiernobiely(), čiernobiely(boolean), čiernobiely(double, double, double), farebnýFilter(Color), farebnéTienidlo(Color)
  - monochromaticky
```
public void monochromaticky(Color farba)
```
    Alias pre monochromatický.
  - jednofarebný
```
public void jednofarebný(Color farba)
```
    Alias pre monochromatický.
  - jednofarebny
```
public void jednofarebny(Color farba)
```
    Alias pre monochromatický.
  - farebnýFilter
```
public void farebnýFilter(Color farba)
```
    Použije na tento obrázok zadaný farebný filter. Obrázok nadobudne vzhľad, ako keby sme sa na neho pozerali cez filter prepúšťajúci len zadanú farbu.
    
    Porovnanie rôznych efektov použitých na rovnaký obrázok je v opise metódy farebnéTienidlo(farba).
    
    Poznámka: Metóda zachováva aj kanál priehľadnosti obrázka.
    
    Parametre:
    
    farba – farba filtra
    
    Pozri tiež:
    
    čiernobiely(), čiernobiely(boolean), čiernobiely(double, double, double), monochromatický(Color), farebnéTienidlo(Color)
  - farebnyFilter
```
public void farebnyFilter(Color farba)
```
    Alias pre farebnýFilter.
  - farebnéTienidlo
```
public void farebnéTienidlo(Color farba)
```
    Použije na tento obrázok zadané farebné tienidlo. Obrázok nadobudne vzhľad, ako keby sme sa na neho pozerali cez tienidlo, ktoré má zadanú farbu. Všetky farby v obrázku (ich zložky) budú posunuté smerom k zadanej farbe.
    
    Poznámka: Metóda zachováva aj kanál priehľadnosti obrázka.
    
    Nasledujúci obrázok zhromažďuje a porovnáva rôzne efekty použité na tú istú predlohu:
    
    Porovnanie rôznych efekty aplikovaných na ten istý obrázok.
    
    V bloku A je pôvodný obrázok. Blok B obsahuje použitie efektu posterizácie s a bez algoritmu difúzie chyby (prvý riadok bloku je bez difúzie chyby, druhý s ňou). Stĺpce bloku sú posterizované postupne s použitím troch farieb (červenej, zelenej a modrej), šiestich farieb (pribudla tyrkysová, purpurová a žltá) a staršej verzie predvolenej palety preddefinovaných farieb.
    
    V bloku C sú pod sebou použité efekty monochromatickosti, farebného filtra a farebného tienidla s červenou farbou. Blok D obsahuje vedľa seba použitie tých istých efektov so zelenou farbou a blok E s modrou farbou.
    
    Parametre:
    
    farba – farba tienidla
    
    Pozri tiež:
    
    čiernobiely(), čiernobiely(boolean), čiernobiely(double, double, double), monochromatický(Color), farebnýFilter(Color)
  - farebneTienidlo
```
public void farebneTienidlo(Color farba)
```
    Alias pre farebnéTienidlo.
  - monochromatický
```
public void monochromatický(Farebnosť objekt)
```
    Upraví tento obrázok do odtieňov farby zadaného objektu. Monochromatická zložka, čiže zložka jasu (odtiene šedej), bude násobená farebnými zložkami farby zadaného objektu. Výsledkom bude obrázok v odtieňoch jeho farby. Ak má objekt čiernu farbu, získame čierny obrázok. Ak má objekt bielu farbu, dostaneme čiernobiely obrázok. Ľubovoľná iná farba objektu zafarbí obrázok do jej odtieňov.
    
    Parametre:
    
    objekt – objekt, do odtieňov farby ktorého bude obrázok prevedený
  - monochromaticky
```
public void monochromaticky(Farebnosť objekt)
```
    Alias pre monochromatický.
  - jednofarebný
```
public void jednofarebný(Farebnosť objekt)
```
    Alias pre monochromatický.
  - jednofarebny
```
public void jednofarebny(Farebnosť objekt)
```
    Alias pre monochromatický.
  - farebnýFilter
```
public void farebnýFilter(Farebnosť objekt)
```
    Použije na tento obrázok farebný filter podľa farby zadaného objektu. Obrázok nadobudne vzhľad, ako keby sme sa na neho pozerali cez sklo farby zadaného objektu.
    
    Parametre:
    
    objekt – objekt určujúci farbu filtra
  - farebnyFilter
```
public void farebnyFilter(Farebnosť objekt)
```
    Alias pre farebnýFilter.
  - zrušPriehľadnosť
```
public void zrušPriehľadnosť()
```
    Zruší priehľadnosť všetkých bodov v obrázku.
    
    Pozor! Volanie tejto metódy neovplyvní celkovú priehľadnosť obrázka ovplyvňovanú metódami priehľadnosť(priehľadnosť), priehľadnosť(objekt) a upravPriehľadnosť(zmena).
    
    Poznámka: Princíp toho, ako funguje zrušenie priehľadnosti, je ukázaný v opise rovnomennej metódy triedy Plátno – zrušPriehľadnosť.
  - zrusPriehladnost
```
public void zrusPriehladnost()
```
    Alias pre zrušPriehľadnosť.
  - použiMasku
```
public boolean použiMasku(BufferedImage maska)
```
    Použije na tento obrázok masku vyrobenú zo zadaného obrázka. Maska musí mať rovnaký rozmer ako obrázok, inak operácia zlyhá. Maska je vyrobená z kombinácie intenzity farieb a priehľadnosti jednotlivých bodov zadaného obrázka. Čím je bod masky tmavší, tým bude viditeľnejší, čím svetlejší, tým menej viditeľný. Jas je korigovaný aj zložkami priehľadnosti obidvoch bodov, teda ako pôvodného bodu na obrázku, tak aj bodu prevzatého z masky. Ak je súčin ich zložiek priehľadnosti rovný nule, tak bude výsledný bod neviditeľný. Viditeľnosť bodov v ostatných prípadoch záleží na výsledku výpočtov algoritmu. Napríklad úplne čierne úplne nepriehľadné body masky neovplyvnia priehľadnosť bodov na obrázku.
    
    Upozornenie: Maska nie je pri exporte kreslenia do inštancie SVGPodpora použitá priamo, pretože pracuje s rastrom obrázkov/plátien. Ak chcete do SVG podpory exportovať vlastnú masku, použite kombináciu vlastnej definície (vložením záznamu <mask id="ID masky">…</mask>) a atribútu mask="url(#ID masky)". Podrobnosti o SVG maskách nájdete napríklad tu:
    Clipping and masking – SVG : Scalable Vector Graphics | MDN. Mozilla Developer Network, developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Clipping_and_masking#masking. Naposledy pristúpené: 28. januára 2023.
    Môžete tiež použiť orezávanie – pozri napríklad tu.
    
    Parametre:
    
    maska – obrázok, ktorý bude použitý ako maska
    
    Návratová hodnota:
    
    true ak bola operácia úspešná
  - pouziMasku
```
public boolean pouziMasku(BufferedImage maska)
```
    Alias pre použiMasku.
  - vymažKresbu
```
public boolean vymažKresbu(BufferedImage kresba)
```
    Použije na tento obrázok filter vyrobený zo zložky jasu kresby zadaného/predloženého obrázka. Zložka priehľadnosti bodov na obrázku, ktorý poslúži ako predloha pre filter nie je braná do úvahy. Hodnoty farebných zložiek úplne priehľadných (neviditeľných) bodov sú nepredvídateľné, preto by mal byť obrázok predlohy filtra úplne pokrytý nepriehľadnou kresbou. Svetlé/biele body na obrázku predlohy spôsobia vymazanie bodov na tomto obrázku (nastavenie hodnôt všetkých ich farebných zložiek a priehľadnosti na nulu). Tmavé/čierne body na predloženom obrázku nespôsobia na tomto obrázku žiadnu zmenu priehľadnosti. (Ostatné odtiene šedej a farebné body vo filtri spôsobia nastavenie úrovne priehľadnosti bodov obrázka na hodnotu jasu vypočítanú z priemeru farebných zložiek bodov filtra.) Obrázok s predlohou musí mať rovnaký rozmer ako tento obrázok, inak operácia zlyhá.
    
    Parametre:
    
    kresba – obrázok, ktorý bude použitý ako predloha pre filter
    
    Návratová hodnota:
    
    true ak bola operácia úspešná
  - vymazKresbu
```
public boolean vymazKresbu(BufferedImage kresba)
```
    Alias pre vymažKresbu.
  - vyrobMasku
```
public boolean vyrobMasku(BufferedImage nováMaska)
```
    Vyrobí z tohto obrázka do zadaného obrázka masku priehľadnosti. Zadaný obrázok musí mať rovnakú veľkosť ako tento obrázok, inak operácia zlyhá. Vyrobená maska bude obsahovať čierne body rôznej priehľadnosti podľa priehľadnosti bodov pôvodného obrázka. Pôvodný obsah zadaného obrázka (argumentu nováMaska) bude nahradený.
    
    Parametre:
    
    nováMaska – obrázok, do ktorého bude nová maska vyrobená (pôvodný obsah obrázka bude nahradený maskou)
    
    Návratová hodnota:
    
    true ak bola operácia úspešná
  - vyrobMasku
```
public BufferedImage vyrobMasku()
```
    Vyrobí z tohto obrázka masku priehľadnosti. Metóda vytvorí masku do nového obrázka (typu BufferedImage), ktorý sama automaticky vytvorí a vráti ako svoj výsledok (návratovú hodnotu). Nová maska bude obsahovať čierne body rôznej priehľadnosti vychádzajúc z priehľadnosti bodov tohto obrázka.
    
    Návratová hodnota:
    
    nový obrázok obsahujúci vyrobenú masku
  - rozmaž
```
public void rozmaž(int opakovanie,
                   int rozsah,
                   Color pozadie)
```
    Rozmaže grafiku obrázka. Pre priehľadné (neviditeľné) body je pri procese rozmazania použitá zadaná farba pozadia. Opakovanie a rozsah majú z vizuálneho hľadiska podobný dopad na výsledný efekt rozmazania, ale matice lineárneho kruhového rozmazania sú vygenerované len do úrovne rozsahu 5 (vrátane). Pri zadaní vyššej hodnoty rozsahu získame rovnaký efekt ako keby sme zadali hodnotu 5. Ak chceme dosiahnuť vyššiu mieru rozmazania, musíme zvýšiť počet opakovaní procesu rozmazania (argument opakovanie). Čím vyššie sú hodnoty opakovania a rozsahu, tým vyššie sú nároky metódy na výpočtový výkon.
    
    Parametre:
    
    opakovanie – počet opakovaní rozmazania
    
    rozsah – rozsah rozmazania; reálny efekt dosiahneme len v rozsahu hodnôt 1 – 5, vyššie čísla sú zaokrúhlené na 5, nižšie nespôsobia žiadne rozmazanie
    
    pozadie – farba použitá pri procese rozmazania pre priehľadné body
  - rozmaz
```
public void rozmaz(int opakovanie,
                   int rozsah,
                   Color pozadie)
```
    Alias pre rozmaž.
  - rozmaž
```
public void rozmaž(int opakovanie,
                   Color pozadie)
```
    Rozmaže grafiku obrázka. Dosiahneme rovnaký efekt, ako keby sme volali metódu: rozmaž(opakovanie, 1, pozadie);
    
    Parametre:
    
    opakovanie – počet opakovaní rozmazania
    
    pozadie – farba použitá pre neviditeľné body
  - rozmaz
```
public void rozmaz(int opakovanie,
                   Color pozadie)
```
    Alias pre rozmaž.
  - rozmaž
```
public void rozmaž(Color pozadie)
```
    Rozmaže grafiku obrázka. Dosiahneme rovnaký efekt, ako keby sme volali metódu: rozmaž(1, 1, pozadie);
    
    Parametre:
    
    pozadie – farba použitá pre neviditeľné body
  - rozmaz
```
public void rozmaz(Color pozadie)
```
    Alias pre rozmaž.
  - rozmaž
```
public void rozmaž(int opakovanie,
                   int rozsah,
                   Farebnosť pozadie)
```
    Rozmaže grafiku obrázka. Pre priehľadné (neviditeľné) body je pri procese rozmazania použitá zadaná farba pozadia. Opakovanie a rozsah majú z vizuálneho hľadiska podobný dopad na výsledný efekt rozmazania, ale matice lineárneho kruhového rozmazania sú vygenerované len do úrovne rozsahu 5 (vrátane). Pri zadaní vyššej hodnoty rozsahu získame rovnaký efekt ako keby sme zadali hodnotu 5. Ak chceme dosiahnuť vyššiu mieru rozmazania, musíme zvýšiť počet opakovaní procesu rozmazania (argument opakovanie). Čím vyššie sú hodnoty opakovania a rozsahu, tým vyššie sú nároky metódy na výpočtový výkon.
    
    Parametre:
    
    opakovanie – počet opakovaní rozmazania
    
    rozsah – rozsah rozmazania; reálny efekt dosiahneme len v rozsahu hodnôt 1 – 5, vyššie čísla sú zaokrúhlené na 5, nižšie nespôsobia žiadne rozmazanie
    
    pozadie – farba použitá pri procese rozmazania pre priehľadné body
  - rozmaz
```
public void rozmaz(int opakovanie,
                   int rozsah,
                   Farebnosť pozadie)
```
    Alias pre rozmaž.
  - rozmaž
```
public void rozmaž(int opakovanie,
                   Farebnosť pozadie)
```
    Rozmaže grafiku obrázka. Dosiahneme rovnaký efekt, ako keby sme volali metódu: rozmaž(opakovanie, 1, pozadie);
    
    Parametre:
    
    opakovanie – počet opakovaní rozmazania
    
    pozadie – farba použitá pre neviditeľné body
  - rozmaz
```
public void rozmaz(int opakovanie,
                   Farebnosť pozadie)
```
    Alias pre rozmaž.
  - rozmaž
```
public void rozmaž(Farebnosť pozadie)
```
    Rozmaže grafiku obrázka. Dosiahneme rovnaký efekt, ako keby sme volali metódu: rozmaž(1, 1, pozadie);
    
    Parametre:
    
    pozadie – farba použitá pre neviditeľné body
  - rozmaz
```
public void rozmaz(Farebnosť pozadie)
```
    Alias pre rozmaž.
  - rozmaž
```
public void rozmaž(int opakovanie,
                   int rozsah)
```
    Rozmaže grafiku obrázka. Dosiahneme rovnaký efekt, ako keby sme volali metódu: rozmaž(opakovanie, rozsah, Svet.farbaPozadia()); To znamená, že pre priehľadné (neviditeľné) body je pri procese rozmazania použitá aktuálna farba pozadia sveta (pozri: Svet.farbaPozadia(farba)).
    
    Parametre:
    
    opakovanie – počet opakovaní rozmazania
    
    rozsah – rozsah rozmazania
  - rozmaz
```
public void rozmaz(int opakovanie,
                   int rozsah)
```
    Alias pre rozmaž.
  - rozmaž
```
public void rozmaž(int opakovanie)
```
    Rozmaže grafiku obrázka. Dosiahneme rovnaký efekt, ako keby sme volali metódu: rozmaž(opakovanie, 1, Svet.farbaPozadia()); To znamená, že pre priehľadné (neviditeľné) body je pri procese rozmazania použitá aktuálna farba pozadia sveta (pozri: Svet.farbaPozadia(farba)).
    
    Parametre:
    
    opakovanie – počet opakovaní rozmazania
  - rozmaz
```
public void rozmaz(int opakovanie)
```
    Alias pre rozmaž.
  - rozmaž
```
public void rozmaž()
```
    Rozmaže grafiku obrázka. Dosiahneme rovnaký efekt, ako keby sme volali metódu: rozmaž(1, 1, Svet.farbaPozadia()); To znamená, že pre priehľadné (neviditeľné) body je pri procese rozmazania použitá aktuálna farba pozadia sveta (pozri: Svet.farbaPozadia(farba)).
  - rozmaz
```
public void rozmaz()
```
    Alias pre rozmaž.
  - rozmaž
```
public void rozmaž(int opakovanie,
                   int rozsah,
                   int bgr,
                   int bgg,
                   int bgb)
```
    Rozmaže grafiku obrázka. Dosiahneme rovnaký efekt, ako keby sme volali metódu: rozmaž(opakovanie, rozsah, new Farba(bgr, bgg, bgb));
    
    Parametre:
    
    opakovanie – počet opakovaní rozmazania
    
    rozsah – rozsah rozmazania
    
    bgr – červený komponent pozadia
    
    bgg – zelený komponent pozadia
    
    bgb – modrý komponent pozadia
  - rozmaz
```
public void rozmaz(int opakovanie,
                   int rozsah,
                   int bgr,
                   int bgg,
                   int bgb)
```
    Alias pre rozmaž.
  - rozmaž
```
public void rozmaž(int opakovanie,
                   int bgr,
                   int bgg,
                   int bgb)
```
    Rozmaže grafiku obrázka. Dosiahneme rovnaký efekt, ako keby sme volali metódu: rozmaž(opakovanie, 1, new Farba(bgr, bgg, bgb));
    
    Parametre:
    
    opakovanie – počet opakovaní rozmazania
    
    bgr – červený komponent pozadia
    
    bgg – zelený komponent pozadia
    
    bgb – modrý komponent pozadia
  - rozmaz
```
public void rozmaz(int opakovanie,
                   int bgr,
                   int bgg,
                   int bgb)
```
    Alias pre rozmaž.
  - rozmaž
```
public void rozmaž(int bgr,
                   int bgg,
                   int bgb)
```
    Rozmaže grafiku obrázka. Dosiahneme rovnaký efekt, ako keby sme volali metódu: rozmaž(1, 1, new Farba(bgr, bgg, bgb));
    
    Parametre:
    
    bgr – červený komponent pozadia
    
    bgg – zelený komponent pozadia
    
    bgb – modrý komponent pozadia
  - rozmaz
```
public void rozmaz(int bgr,
                   int bgg,
                   int bgb)
```
    Alias pre rozmaž.
  - upravJasKontrast
```
public void upravJasKontrast(double jas,
                             double kontrast)
```
    Upraví parametre jasu a kontrastu celého obrázka. Oba parametre môžu nadobúdať kladné aj záporné hodnoty. Na obrázkoch nižšie je vidno, ako sa zmení obrázok pri rôznych hodnotách týchto parametrov.
    
    Zdrojový obrázok na ukážku úpravy jasu a kontrastu
    (verzia v mierne vyššom rozlíšení je dostupná na prevzatie tu).
    
    -240,0 -160,0 -80,0 0,0 80,0 160,0 240,0
    
    -240,0
    
    -160,0
    
    -80,0
    
    0,0
    
    80,0
    
    160,0
    
    240,0
    
    rôzne úrovne jasu
    
    Ukážka rôznych úrovní jasu a kontrastu.
    
    Zdrojový obrázok na ukážku úpravy jasu a kontrastu
    (verzia v mierne vyššom rozlíšení je dostupná na prevzatie tu).
    
    -240,0 -160,0 -80,0 0,0 80,0 160,0 240,0
    
    -240,0
    
    -160,0
    
    -80,0
    
    0,0
    
    80,0
    
    160,0
    
    240,0
    
    rôzne úrovne jasu
    
    Ukážka rôznych úrovní jasu a kontrastu.
    
    Poznámka: Úplne priehľadné (neviditeľné) body nie sú spracované. Tento efekt ukazuje nasledujúci obrázok, na ktorého vytvorenie bola použitá aj metóda zrušPriehľadnosť.
    
    a) b) c)
    
    Ukážka vplyvu metódy upravJasKontrast na priehľadné časti obrázka:
    a) vygenerovaný obrázok s priehľadnými časťami,
    b) obrázok po volaní metód upravJasKontrast(-240, 160) a zrušPriehľadnosť(),
    c) zvýraznenie pôvodne priehľadných častí, na ktoré nemalo volanie metódy upravJasKontrast žiadny vplyv.
    
    Použité zdroje:
    - Francis G. Loch: Image Processing Algorithms Part 4: Brightness Adjustment. Dreamland Fantasy Studios, 2008, 2010. Citované: 2018.
    - Francis G. Loch: Image Processing Algorithms Part 4: Brightness Adjustment. Dreamland Fantasy Studios, 2008, 2010. Citované: 2018.
    Parametre:
    
    jas – reálnočíselná hodnota určujúca mieru zmeny jasu obrázka; relevantné sú hodnoty v rozmedzí od −255.0 do 255.0
    
    kontrast – reálnočíselná hodnota určujúca mieru zmeny kontrastu obrázka; relevantné sú hodnoty v rozmedzí od −255.0 do 255.0
  - gamaKorekcia
```
public void gamaKorekcia(double γ)
```
    Upraví intenzitu farieb obrázka na základe hodnoty parametra gama (γ). Gama vyjadruje vzťah medzi vstupnou a výstupnou hodnotou intenzity farby, ktorý je najlepšie viditeľný na nasledujúcom grafe:
    
    Graf vyjadrujúci zmenu vstupnej veličiny na výstupnú pri rôznych hodnotách faktora gama (γ).
    
    Poznámka: Algoritmus môže principiálne prijímať akúkoľvek hodnotu γ, okrem nuly, ale tento prípad je v metóde ošetrený zadaním paušálnej hodnoty korekcie 65 025, takže aj v tom prípade produkuje metóda relatívne korektný výsledok. Záporné hodnoty sú tiež mimo rozsahu korektných hodnôt, ale metóda ich nefiltruje, pretože zadaním zápornej hodnoty sa dá získať síce nesprávny, ale zaujímavý výsledok. Odporúčaný rozsah hodnôt sa nachádza v rozmedzí 0,01 – 7,99.
    
    Nasledujúci obrázok ukazuje vplyv rôznych úrovní gama korekcie na dvoch obrázkoch, ktoré sú k dispozícii na prevzatie v opise metódy upravJasKontrast.
    
    Úprava dvoch obrázkov gama korekciou s hodnotami (zľava): 0.01, 0.25, 0.5, 1.0, 2.0, 4.0 a 7.99.
    
    Poznámka: Úplne priehľadné (neviditeľné) body nie sú spracované. Nasledujúci príklad vygeneruje kresbu s bublinkami, na ktorej je táto vlastnosť ukázaná.
    
    Príklad:
    
    Tento príklad vygeneruje obrázok s bublinkami, ktoré sa vzájomne prekrývajú. Prekrývanie je riešené vymazaním (spriehľadnením) tej časti kresby, ktorú bude tvoriť nasledujúca nakreslená bublinka. Následne je na kresbu použitá gama korekcia a metóda zrušPriehľadnosť(), čím sa ukážu aj pôvodne spriehľadnené časti kresby, na ktoré nemala gama korekcia vplyv.
```
// Generovanie náhodných bubliniek.
Obrázok bublinky = new Obrázok(400, 400);
Obrázok guma = new Obrázok(400, 400);
hrúbkaČiary(5.5);
for (int i = 0; i < 100; ++i)
{
    náhodnáPoloha();
    smer(90);
    long polomer = Svet.náhodnéCeléČíslo(30, 50);

    guma.vyplň(čierna);
    farba(biela);
    kresliDoObrázka(guma);
    kruh(polomer);
    bublinky.vymažKresbu(guma);

    switch (i % 3)
    {
    case 0: farba(svetlotyrkysová); break;
    case 1: farba(tyrkysová); break;
    case 2: farba(tmavotyrkysová);
    }

    kresliDoObrázka(bublinky);
    kružnica(polomer);
    preskočVľavo(polomer * 0.7);
    choďPoOblúku(90, polomer * 0.7);
}

// Úprava obrázka s použitím gama korekcie a zrušenie priehľadnosti
// bodov v obrázku.
bublinky.gamaKorekcia(0.1);
bublinky.zrušPriehľadnosť();
```
    Výsledok:
    
    Vľavo je verzia obrázka pred a vpravo po úprave gama korekciou (γ = 0,1) s odhalením priehľadných častí kresby metódou zrušPriehľadnosť().
    
    Použitý zdroj:
    - Francis G. Loch: Image Processing Algorithms Part 6: Gamma Correction. Dreamland Fantasy Studios, 2008, 2010. Citované: 2018.
    Parametre:
    
    γ – hodnota, ktorá určí mieru korekcie intenzity farieb obrázka; vhodný rozsah hodnôt je zhruba v rozmedzí 0,01 – 7,99
  - posterizuj
```
public void posterizuj()
```
    Posterizuje obrázok podľa predvolenej palety preddefinovaných farieb. Pod posterizáciou sa rozumie nastavenie všetkých farieb na najbližšiu farbu v palete.
    
    Poznámka: Táto metóda zruší priehľadnosť bodov pôvodného obrázka. Ak ju chcete zachovať, musíte vytvoriť a použiť masku.
    
    Vľavo je verzia obrázka pred a vpravo po úprave touto metódou.
    
    Porovnanie rôznych efektov použitých na rovnaký obrázok je aj v opise metódy farebnéTienidlo(farba).
    
    Pozri tiež:
    
    posterizuj(Color, Color...), posterizuj(Color[]), posterizuj(boolean), posterizuj(boolean, Color, Color...), posterizuj(boolean, Color[])
  - posterizuj
```
public void posterizuj(Color prváFarba,
                       Color... ostatnéFarby)
```
    Posterizuje obrázok podľa palety zadanej vo forme zoznamu farieb, pričom povinné je zadanie aspoň jednej farby. Pod posterizáciou sa rozumie nastavenie všetkých farieb na najbližšiu farbu v palete. Ak je zadaná len jedna farba palety, tak ňou bude obrázok jednoducho vyplnený.
    
    Poznámka: Táto metóda zruší priehľadnosť bodov pôvodného obrázka. Ak ju chcete zachovať, musíte vytvoriť a použiť masku.
    
    Vľavo je verzia obrázka pred a vpravo po úprave touto metódou s parametrami: červená, zelená, modrá, čierna, biela, šedá, žltá, tyrkysová, purpurová.
    
    Porovnanie rôznych efektov použitých na rovnaký obrázok je aj v opise metódy farebnéTienidlo(farba).
    
    Parametre:
    
    prváFarba – prvá farba palety na posterizáciu
    
    ostatnéFarby – zoznam ostatných farieb palety na posterizáciu
    
    Pozri tiež:
    
    posterizuj(), posterizuj(Color[]), posterizuj(boolean), posterizuj(boolean, Color, Color...), posterizuj(boolean, Color[])
  - posterizuj
```
public void posterizuj(Color[] paleta)
```
    Posterizuje obrázok podľa palety zadanej vo forme poľa farieb. Pod posterizáciou sa rozumie nastavenie všetkých farieb na najbližšiu farbu v palete. Ak paleta obsahuje len jednu farbu, tak ňou bude obrázok jednoducho vyplnený.
    
    Poznámka: Táto metóda zruší priehľadnosť bodov pôvodného obrázka. Ak ju chcete zachovať, musíte vytvoriť a použiť masku.
    
    Vľavo je verzia obrázka pred a vpravo po úprave touto metódou s parametrom: «inštancia».paleta(32).
    
    Porovnanie rôznych efektov použitých na rovnaký obrázok je aj v opise metódy farebnéTienidlo(farba).
    
    Použitý zdroj:
    - Francis G. Loch: Image Processing Algorithms Part 1: Finding The Nearest Colour. Dreamland Fantasy Studios, 2008, 2010. Citované: 2018.
    Parametre:
    
    paleta – paleta na posterizáciu
    
    Pozri tiež:
    
    posterizuj(), posterizuj(Color, Color...), posterizuj(boolean), posterizuj(boolean, Color, Color...), posterizuj(boolean, Color[]), početFarieb(), paleta(int)
  - posterizuj
```
public void posterizuj(boolean difúziaChyby)
```
    Posterizuje obrázok podľa predvolenej palety preddefinovaných farieb a umožňuje zvoliť, či má byť pri tomto procese použitý algoritmus difúzie chyby. Pre posterizáciu platí to isté, čo je uvedené v opise metódy posterizuj(). Algoritmus difúzie chyby prenáša časť chyby zaokrúhlenia farieb na susedné pixely, čo vo výsledku vyvolá optický klam – dojem, že posterizovaný obrázok má v skutočnosti viac farieb, než obsahovala paleta použitá pri posterizácii (čo nie je pravda).
    
    Poznámka: Táto metóda zruší priehľadnosť bodov pôvodného obrázka. Ak ju chcete zachovať, musíte vytvoriť a použiť masku.
    
    Vľavo je verzia obrázka pred a vpravo po úprave touto metódou s parametrom: true.
    
    Porovnanie rôznych efektov použitých na rovnaký obrázok je aj v opise metódy farebnéTienidlo(farba).
    
    Parametre:
    
    difúziaChyby – pravdivostná hodnota určujúca, či má byť pri posterizácii použitý algoritmus difúzie chyby
    
    Pozri tiež:
    
    posterizuj(), posterizuj(Color, Color...), posterizuj(Color[]), posterizuj(boolean, Color, Color...), posterizuj(boolean, Color[])
  - posterizuj
```
public void posterizuj(boolean difúziaChyby,
                       Color prváFarba,
                       Color... ostatnéFarby)
```
    Posterizuje obrázok podľa palety zadanej vo forme zoznamu farieb, pričom povinné je zadanie aspoň jednej farby a umožňuje zvoliť, či má byť pri tomto procese použitý algoritmus difúzie chyby. Pre posterizáciu platí to isté, čo je uvedené v opise metódy posterizuj(prváFarba, ostatnéFarby). Algoritmus difúzie chyby prenáša časť chyby zaokrúhlenia farieb na susedné pixely, čo vo výsledku vyvolá optický klam – dojem, že posterizovaný obrázok má v skutočnosti viac farieb, než obsahovala zadaná paleta (čo nie je pravda).
    
    Poznámka: Táto metóda zruší priehľadnosť bodov pôvodného obrázka. Ak ju chcete zachovať, musíte vytvoriť a použiť masku.
    
    Vľavo je verzia obrázka pred a vpravo po úprave touto metódou s parametrami: true, červená, zelená, modrá, čierna, biela, šedá, žltá, tyrkysová, purpurová.
    
    Porovnanie rôznych efektov použitých na rovnaký obrázok je aj v opise metódy farebnéTienidlo(farba).
    
    Parametre:
    
    difúziaChyby – pravdivostná hodnota určujúca, či má byť pri posterizácii použitý algoritmus difúzie chyby
    
    prváFarba – prvá farba palety na posterizáciu
    
    ostatnéFarby – zoznam ostatných farieb palety na posterizáciu
    
    Pozri tiež:
    
    posterizuj(), posterizuj(Color, Color...), posterizuj(Color[]), posterizuj(boolean), posterizuj(boolean, Color[])
  - posterizuj
```
public void posterizuj(boolean difúziaChyby,
                       Color[] paleta)
```
    Posterizuje obrázok podľa palety zadanej vo forme poľa farieb a umožňuje zvoliť, či má byť pri tomto procese použitý algoritmus difúzie chyby. Pre posterizáciu platí to isté, čo je uvedené v opise metódy posterizuj(paleta). Algoritmus difúzie chyby prenáša časť chyby zaokrúhlenia farieb na susedné pixely, čo vo výsledku vyvolá optický klam – dojem, že posterizovaný obrázok má v skutočnosti viac farieb, než obsahovala zadaná paleta (čo nie je pravda).
    
    Poznámka: Táto metóda zruší priehľadnosť bodov pôvodného obrázka. Ak ju chcete zachovať, musíte vytvoriť a použiť masku.
    
    Vľavo je verzia obrázka pred a vpravo po úprave touto metódou s parametrami: true, «inštancia».paleta(32).
    
    Porovnanie rôznych efektov použitých na rovnaký obrázok je aj v opise metódy farebnéTienidlo(farba).
    
    Použité zdroje:
    - Francis G. Loch: Image Processing Algorithms Part 1: Finding The Nearest Colour. Dreamland Fantasy Studios, 2008, 2010. Citované: 2018.
    - Francis G. Loch: Image Processing Algorithms Part 2: Error Diffusion. Dreamland Fantasy Studios, 2008, 2010. Citované: 2018.
    Parametre:
    
    difúziaChyby – pravdivostná hodnota určujúca, či má byť pri posterizácii použitý algoritmus difúzie chyby
    
    paleta – paleta na posterizáciu
    
    Pozri tiež:
    
    posterizuj(), posterizuj(Color, Color...), posterizuj(Color[]), posterizuj(boolean), posterizuj(boolean, Color, Color...), početFarieb(), paleta(int)
  - početFarieb
```
public int početFarieb()
```
    Zistí počet farieb použitých v aktuálnej snímke obrázka. Metóda neberie do úvahy priehľadnosť farebných bodov, počíta farby len na základe ich farebných zložiek.
    
    Návratová hodnota:
    
    počet farieb v obrázku (bez ohľadu na ich priehľadnosť)
    
    Pozri tiež:
    
    paleta(int), paleta(int, int), posterizuj(Color[]), posterizuj(boolean, Color[])
  - pocetFarieb
```
public int pocetFarieb()
```
    Alias pre početFarieb.
  - paleta
```
public Farba[] paleta(int početFarieb)
```
    Vyrobí paletu najpoužívanejších farieb vyskytujúcich sa v aktuálnej snímke obrázka so zadaným maximálnym počtom farieb. Metóda funguje rovnako ako metóda paleta(početFarieb, hranicaZdravia) s predvolenou hranicou zdravia 256. (Ďalšie podrobnosti pozri v opise uvedenej metódy.)
    
    Parametre:
    
    početFarieb – maximálny počet farieb, ktoré smie paleta obsahovať
    
    Návratová hodnota:
    
    paleta farieb obsahujúca zadaný počet farieb
    
    Pozri tiež:
    
    paleta(int, int), početFarieb(), posterizuj(Color[]), posterizuj(boolean, Color[])
  - paleta
```
public Farba[] paleta(int početFarieb,
                      int hranicaZdravia)
```
    Vyrobí paletu najpoužívanejších farieb vyskytujúcich sa v aktuálnej snímke obrázka so zadaným maximálnym počtom farieb a hranicou zdravia 256. Metóda zaraďuje farby do palety podľa frekvencie ich výskytu (od najpoužívanejších po najmenej používané). Keď počet farieb, ktoré boli zaradené do palety presiahne zadaný maximálny počet farieb, tak sa metóda pokúsi vypočítať novú farbu ako priemer najbližšej farby a nasledujúcej zadanej farby. Hranica zdravia určuje povolenú vzdialenosť medzi ďalšou pridávanou položkou a jestvujúcou položkou palety (0 znamená, že do palety budú zaradené len prvé najpoužívanejšie položky). Metóda neberie do úvahy priehľadnosť farebných bodov, spracuje všetky body obrázka len na základe ich farebných zložiek a rovnako výsledná paleta bude zložená len z nepriehľadných farieb.
    
    Parametre:
    
    početFarieb – maximálny počet farieb, ktoré smie paleta obsahovať
    
    hranicaZdravia – maximálny vzdialenosť dvoch farieb zaraďovaných do palety ako ich priemer
    
    Návratová hodnota:
    
    paleta farieb obsahujúca zadaný počet farieb
    
    Pozri tiež:
    
    paleta(int), početFarieb(), posterizuj(Color[]), posterizuj(boolean, Color[])
  - svetlo
```
public void svetlo(Obrázok osvetlenie)
```
    Táto metóda použije na tento obrázok zadanú svetelnú masku. Táto operácia nahradí pôvodný obsah obrázka. Správanie tejto metódy je podobné ako správanie metódy svetlo(Obrázok grafika, Obrázok osvetlenie) (pozrite si aj jej opis).
    
    Parametre:
    
    osvetlenie – iný obrázok, ktorého obsah bude použitý na svetelnú úpravu bodov tohto obrázka
    
    Pozri tiež:
    
    svetlo(Obrázok, Obrázok)
  - svetlo
```
public void svetlo(Obrázok grafika,
                   Obrázok osvetlenie)
```
    Táto metóda použije na obrázok zadaný v prvom parametri (grafika) svetelnú masku zadanú v druhom parametri (osvetlenie) a výsledok zlúči do tejto (this) inštancie obrázka. Svetelný filter môže obsahovať ľubovoľné farby. Pravidlom je, že zložka s hodnotou 0x80 je neutrálna, hodnoty zložiek pod touto hranicou výsledný obrázok stmavujú a nad touto hranicou zase zosvetľujú.
    
    Príklad:
    
    Tento príklad prečíta obrázok fotografie, upraví parametre robota tak, aby mohol rýchlo a ľahko vytvárať svetelnú masku so zeleným kruhovým osvetlením (ktoré je premiestňované podľa polohy myši) a masku použije na fotografiu.
```
import knižnica.*;

public class SvetloObrázka extends GRobot
{
    // Čítanie obrázka a vytvorenie jeho kópií
    // (len z dôvodu rýchleho získania obrázkov rovnakých rozmerov)…
    private final static Obrázok zdroj = Obrázok.čítaj("vuje-01.jpeg");
    private final static Obrázok svetlo = new Obrázok(zdroj);
    private final static Obrázok výsledok = new Obrázok(zdroj);

    private SvetloObrázka()
    {
        // Úprava rozmerov a polohy okna (aj plátna):
        super(zdroj.šírka, zdroj.výška);
        Svet.zbaľ();
        Svet.vystreď();

        // Prispôsobenie vlastností robota:
        veľkosť(150);
        farba(new Farba(0x80FF80));
        cieľováFarba(new Farba(0x0080FF80, true));
        kresliDoObrázka(svetlo);
        použiKruhovýNáter();
        skry();

        // Prvé prekreslenie:
        pohybMyši();
    }

    // Keby sme chceli zachovať svetlosť zvyšku obrázka, museli by sme
    // použiť na výplň svetelnej masky túto farbu:
    // ## private final static Farba neutrálna = new Farba(0x808080);

    @Override public void pohybMyši()
    {
        // Vytvorenie svetelnej masky:
        svetlo.vyplň(tmavošedá);
        // ## svetlo.vyplň(neutrálna);
        skočNaMyš();
        kruh();

        // Použitie masky:
        výsledok.svetlo(zdroj, svetlo);

        // Nakreslenie výsledku:
        podlaha.obrázok(výsledok);

        // Keby sme chceli zobraziť len svetelnú masku:
        // ## podlaha.obrázok(svetlo);
    }

    public static void main(String[] args)
    {
        new SvetloObrázka();
    }
}
```
    Pôvodné obrázky na prevzatie: vuje-01.jpeg, vuje-02.jpeg
    
    Výsledok:
    
    Úprava obrázka vuje-01.jpeg – zľava doprava: pôvodný obrázok, svetelná maska, výsledok.
    
    Úprava obrázka vuje-02.jpeg – zľava doprava: pôvodný obrázok, svetelná maska, výsledok.
    Parametre:
    
    grafika – iný obrázok, ktorého obsah bude slúžiť ako predloha osvetleného výsledku uloženého do tohto (this) obrázka
    
    osvetlenie – iný obrázok, ktorého obsah bude použitý na svetelnú úpravu bodov výsledku
    
    Pozri tiež:
    
    svetlo(Obrázok)
  - prevráťZvislo
```
public void prevráťZvislo()
```
    Prevráti obrázok podľa vodorovnej osi – horná časť obrázka sa ocitne dole a naopak.
    
    Pozri tiež:
    
    prevráťVodorovne()
  - prevratZvislo
```
public void prevratZvislo()
```
    Alias pre prevráťZvislo.
  - prevráťVertikálne
```
public void prevráťVertikálne()
```
    Prevráti obrázok podľa vodorovnej osi – horná časť obrázka sa ocitne dole a naopak. Metóda je zároveň aliasom pre prevráťZvislo.
    
    Pozri tiež:
    
    prevráťHorizontálne()
  - prevratVertikalne
```
public void prevratVertikalne()
```
    Alias pre prevráťZvislo.
  - prevráťVodorovne
```
public void prevráťVodorovne()
```
    Prevráti obrázok podľa zvislej osi – pravá časť obrázka sa ocitne vľavo a naopak.
    
    Pozri tiež:
    
    prevráťZvislo()
  - prevratVodorovne
```
public void prevratVodorovne()
```
    Alias pre prevráťVodorovne.
  - prevráťHorizontálne
```
public void prevráťHorizontálne()
```
    Prevráti obrázok podľa zvislej osi – pravá časť obrázka sa ocitne vľavo a naopak. Metóda je zároveň aliasom pre prevráťVodorovne.
    
    Pozri tiež:
    
    prevráťVertikálne()
  - prevratHorizontalne
```
public void prevratHorizontalne()
```
    Alias pre prevráťVodorovne.
  - roluj
```
public void roluj(double Δx,
                  double Δy)
```
    Posunie obsah obrázka o zadaný počet bodov v horizontálnom a/alebo vertikálnom smere. Tá časť obrázka, ktorá opustí jeho rozmery, bude stratená, pričom na protiľahlej strane vznikne prázdna oblasť. Metóda má využitie napríklad pri posune hracej plochy uloženej v obrázku, pričom musíme zabezpečiť, aby boli vzniknuté prázdne časti plochy dokreslené. Ak chceme pretočiť obrázok dookola (t. j. bez straty obsahu), musíme použiť metódu pretoč.
    
    Upozornenie: Je dôležité si uvedomiť, že pri pripojení plazmy k obrázku nemá rolovanie alebo pretáčanie samotného obrázka zmysel, pretože jeho obsah je vždy úplne nahradený generátorom plazmy. Na pretáčanie obsahu takého obrázka má zmysel použiť iba metódy plazmy.
    
    Parametre:
    
    Δx – posun v horizontálnom (vodorovnom) smere
    
    Δy – posun vo vertikálnom (zvislom) smere
  - pretoč
```
public void pretoč(double Δx,
                   double Δy)
```
    Pretočí obsah obrázka o zadaný počet bodov v horizontálnom a/alebo vertikálnom smere. Tá časť obrázka, ktorá by mala pri pretočení opustiť jeho rozmery, sa objaví na protiľahlej strane. Pretáčaním obrázka v ľubovoľnom smere nikdy nestratíme obrazovú informáciu a spätným posunom dostaneme pôvodný obrázok. Ak z rôznych dôvodov potrebujeme, aby sa pri pretáčaní obrázka tie časti, ktoré opustia rozmery obrázka stratili a aby vzniknuté prázdne časti zostali skutočne prázdne (pripravené na ďalšie kreslenie), musíme použiť metódu roluj.
    
    Upozornenie: Je dôležité si uvedomiť, že pri pripojení plazmy k obrázku nemá rolovanie alebo pretáčanie samotného obrázka zmysel, pretože jeho obsah je vždy úplne nahradený generátorom plazmy. Na pretáčanie obsahu takého obrázka má zmysel použiť iba metódy plazmy.
    
    Parametre:
    
    Δx – posun v horizontálnom (vodorovnom) smere
    
    Δy – posun vo vertikálnom (zvislom) smere
  - pretoc
```
public void pretoc(double Δx,
                   double Δy)
```
    Alias pre pretoč.
  - farbaBodu
```
public Farba farbaBodu(double x,
                       double y)
```
    Zistí farbu bodu (jedného pixela) obrázka na zadaných súradniciach v súradnicovom priestore rámca. Funguje podobne ako Plátno.farbaBodu(x, y).
    
    Parametre:
    
    x – x-ová súradnica vyšetrovaného bodu
    
    y – y-ová súradnica vyšetrovaného bodu
    
    Návratová hodnota:
    
    farba bodu (objekt typu Farba) na zadanej pozícii alebo inštancia žiadna, ak sú zadané súradnice mimo rozmerov obrázka
  - farbaBodu
```
public Farba farbaBodu(Poloha objekt)
```
    Zistí farbu bodu (jedného pixela) obrázka na súradniciach určených polohou objektu. Funguje podobne ako farbaBodu(x, y), ale namiesto jednotlivých súradníc sa spracuje poloha zadaného objekt.
    
    Parametre:
    
    objekt – objekt, ktorého poloha určuje súradnice vyšetrovaného bodu
    
    Návratová hodnota:
    
    farba bodu (objekt typu Farba) na pozícii objektu alebo inštancia žiadna, ak je objekt mimo rozmerov obrázka
  - farbaBodu
```
public boolean farbaBodu(double x,
                         double y,
                         Color farba)
```
    Zistí, či sa farba bodu (jedného pixela) obrázka na zadaných súradniciach v súradnicovom priestore rámca zhoduje so zadanou farbou. Funguje podobne ako Plátno.farbaBodu(x, y, farba).
    
    Parametre:
    
    x – x-ová súradnica vyšetrovaného bodu
    
    y – y-ová súradnica vyšetrovaného bodu
    
    farba – farba, ktorú chceme porovnať s farbou bodu na zadanej pozícii
    
    Návratová hodnota:
    
    true ak sú zadané súradnice v rámci rozmerov obrázka a farba bodu na zadaných súradniciach sa zhoduje so zadanou farbou (musia sa zhodovať všetky farebné zložky aj úroveň priehľadnosti), inak false
  - farbaBodu
```
public boolean farbaBodu(Poloha objekt,
                         Color farba)
```
    Zistí, či sa farba bodu (jedného pixela) obrázka na súradniciach zadaného objektu v súradnicovom priestore rámca zhoduje so zadanou farbou. Funguje podobne ako farbaBodu(x, y, farba), ale namiesto jednotlivých súradníc je zadaný objekt, ktorého poloha určuje vyšetrované súradnice.
    
    Parametre:
    
    objekt – objekt, ktorého poloha určuje súradnice vyšetrovaného bodu
    
    farba – farba, ktorú chceme porovnať s farbou bodu na pozícii objektu
    
    Návratová hodnota:
    
    true ak je poloha objektu v rámci rozmerov obrázka a farba bodu na jeho súradniciach sa zhoduje so zadanou farbou (musia sa zhodovať všetky farebné zložky aj úroveň priehľadnosti), inak false
  - farbaBodu
```
public boolean farbaBodu(double x,
                         double y,
                         Farebnosť objekt)
```
    Zistí, či sa farba bodu (jedného pixela) obrázka na zadaných súradniciach v súradnicovom priestore rámca zhoduje s farbou zadaného objektu. Funguje podobne ako Plátno.farbaBodu(x, y, farba).
    
    Parametre:
    
    x – x-ová súradnica vyšetrovaného bodu
    
    y – y-ová súradnica vyšetrovaného bodu
    
    objekt – objekt, ktorého farbu chceme porovnať s farbou bodu na zadanej pozícii
    
    Návratová hodnota:
    
    true ak sú zadané súradnice v rámci rozmerov obrázka a farba bodu na zadaných súradniciach sa zhoduje s farbou zadaného objektu (musia sa zhodovať všetky farebné zložky aj úroveň priehľadnosti), inak false
  - farbaBodu
```
public boolean farbaBodu(Poloha objekt,
                         Farebnosť farebnosť)
```
    Zistí, či sa farba bodu (jedného pixela) obrázka na súradniciach prvého zadaného objektu (v súradnicovom priestore rámca) zhoduje s farbou druhého zadaného objektu. Funguje podobne ako farbaBodu(x, y, farba), ale namiesto jednotlivých súradníc je spracovaná poloha objektu.
    
    Parametre:
    
    objekt – objekt, ktorého poloha určuje súradnice vyšetrovaného bodu
    
    farebnosť – objekt, ktorého farbu chceme porovnať s farbou bodu na pozícii objektu
    
    Návratová hodnota:
    
    true ak je poloha objektu v rámci rozmerov obrázka a farba bodu na jeho súradniciach sa zhoduje s farbou zadaného objektu (musia sa zhodovať všetky farebné zložky aj úroveň priehľadnosti), inak false
  - farbaBodu
```
public boolean farbaBodu(double x,
                         double y,
                         int r,
                         int g,
                         int b)
```
    Zistí, či sa farba bodu (jedného pixela) obrázka na zadaných súradniciach v súradnicovom priestore rámca zhoduje s farbou zadanou prostredníctvom farebných zložiek. (Úroveň priehľadnosti je nastavená na hodnotu 255, čiže na úplne nepriehľadnú farbu.) Funguje podobne ako Plátno.farbaBodu(x, y, farba), ale farba je určená prostredníctvom farebných zložiek.
    
    Parametre:
    
    x – x-ová súradnica vyšetrovaného bodu
    
    y – y-ová súradnica vyšetrovaného bodu
    
    r – červená zložka farby, ktorú chceme porovnať s farbou bodu na zadanej pozícii
    
    g – červená zložka farby, ktorú chceme porovnať s farbou bodu na zadanej pozícii
    
    b – červená zložka farby, ktorú chceme porovnať s farbou bodu na zadanej pozícii
    
    Návratová hodnota:
    
    true ak sú zadané súradnice v rámci rozmerov obrázka a farba bodu na zadaných súradniciach sa zhoduje so zadanou farbou (musia sa zhodovať všetky farebné zložky aj úroveň priehľadnosti), inak false
  - farbaBodu
```
public boolean farbaBodu(double x,
                         double y,
                         int r,
                         int g,
                         int b,
                         int a)
```
    Zistí, či sa farba bodu (jedného pixela) obrázka na zadaných súradniciach v súradnicovom priestore rámca zhoduje s farbou zadanou prostredníctvom farebných zložiek a úrovne priehľadnosti. Funguje podobne ako Plátno.farbaBodu(x, y, farba), ale farba je určená prostredníctvom farebných zložiek a úrovne priehľadnosti.
    
    Parametre:
    
    x – x-ová súradnica vyšetrovaného bodu
    
    y – y-ová súradnica vyšetrovaného bodu
    
    r – červená zložka farby, ktorú chceme porovnať s farbou bodu na zadanej pozícii
    
    g – červená zložka farby, ktorú chceme porovnať s farbou bodu na zadanej pozícii
    
    b – červená zložka farby, ktorú chceme porovnať s farbou bodu na zadanej pozícii
    
    a – úroveň priehľadnosti farby, ktorú chceme porovnať s farbou bodu na zadanej pozícii
    
    Návratová hodnota:
    
    true ak sú zadané súradnice v rámci rozmerov obrázka a farba bodu na zadaných súradniciach sa zhoduje so zadanou farbou (musia sa zhodovať všetky farebné zložky aj úroveň priehľadnosti), inak false
  - farbaBodu
```
public boolean farbaBodu(Poloha objekt,
                         int r,
                         int g,
                         int b)
```
    Zistí, či sa farba bodu (jedného pixela) obrázka na súradniciach zadaného objektu (v súradnicovom priestore rámca) zhoduje s farbou zadanou prostredníctvom farebných zložiek a úrovne. (Úroveň priehľadnosti je nastavená na hodnotu 255, čiže na úplne nepriehľadnú farbu.) Funguje podobne ako farbaBodu(x, y, farba), ale namiesto jednotlivých súradníc je spracovaná poloha objektu a farba je určená prostredníctvom farebných zložiek.
    
    Parametre:
    
    objekt – objekt, ktorého poloha určuje súradnice vyšetrovaného bodu
    
    r – červená zložka farby, ktorú chceme porovnať s farbou bodu na pozícii objektu
    
    g – červená zložka farby, ktorú chceme porovnať s farbou bodu na pozícii objektu
    
    b – červená zložka farby, ktorú chceme porovnať s farbou bodu na pozícii objektu
    
    Návratová hodnota:
    
    true ak je poloha objektu v rámci rozmerov obrázka a farba bodu na jeho súradniciach sa zhoduje so zadanou farbou (musia sa zhodovať všetky farebné zložky aj úroveň priehľadnosti), inak false
  - farbaBodu
```
public boolean farbaBodu(Poloha objekt,
                         int r,
                         int g,
                         int b,
                         int a)
```
    Zistí, či sa farba bodu (jedného pixela) obrázka na súradniciach zadaného objektu (v súradnicovom priestore rámca) zhoduje s farbou zadanou prostredníctvom farebných zložiek a úrovne priehľadnosti. Funguje podobne ako farbaBodu(x, y, farba), ale namiesto jednotlivých súradníc je spracovaná poloha objektu a farba je určená prostredníctvom farebných zložiek a úrovne priehľadnosti.
    
    Parametre:
    
    objekt – objekt, ktorého poloha určuje súradnice vyšetrovaného bodu
    
    r – červená zložka farby, ktorú chceme porovnať s farbou bodu na pozícii objektu
    
    g – červená zložka farby, ktorú chceme porovnať s farbou bodu na pozícii objektu
    
    b – červená zložka farby, ktorú chceme porovnať s farbou bodu na pozícii objektu
    
    a – úroveň priehľadnosti farby, ktorú chceme porovnať s farbou bodu na pozícii objektu
    
    Návratová hodnota:
    
    true ak je poloha objektu v rámci rozmerov obrázka a farba bodu na jeho súradniciach sa zhoduje so zadanou farbou (musia sa zhodovať všetky farebné zložky aj úroveň priehľadnosti), inak false
  - priehľadnosť
```
public double priehľadnosť()
```
    Zistí aktuálnu úroveň priehľadnosti tohto obrázka.
    
    Definované:
    
    priehľadnosť v rozhraní Priehľadnosť
    
    Návratová hodnota:
    
    aktuálna úroveň priehľadnosti tohto obrázka
    
    Pozri tiež:
    
    priehľadnosť(double), upravPriehľadnosť(double)
  - priehladnost
```
public double priehladnost()
```
    Alias pre priehľadnosť.
    
    Definované:
    
    priehladnost v rozhraní Priehľadnosť
  - priehľadnosť
```
public void priehľadnosť(double priehľadnosť)
```
    Nastaví novú úroveň (ne)priehľadnosti tohto obrázka, pričom jednotlivé body na obrázku môžu mať svoju vlastnú úroveň priehľadnosti. Úroveň 0.0 znamená, že obrázok nebude pri kreslení zobrazený. Úroveň 1.0 znamená, že jednotlivé body obrázka budú zobrazené s ich vlastnou úrovňou priehľadnosti – nepriehľadné body budú plne viditeľné. Úroveň priehľadnosti obrázka nemá vplyv na jeho uloženie do súboru, iba na jeho zobrazenie.
    
    Parametre:
    
    priehľadnosť – nová úroveň priehľadnosti (0.0 – 1.0)
    
    Pozri tiež:
    
    priehľadnosť(), upravPriehľadnosť(double)
  - priehladnost
```
public void priehladnost(double priehľadnosť)
```
    Alias pre priehľadnosť.
  - priehľadnosť
```
public void priehľadnosť(Priehľadnosť objekt)
```
    Skopíruje úroveň (ne)priehľadnosti zo zadaného objektu.
    
    Parametre:
    
    objekt – objekt určujúci novú úroveň priehľadnosti
    
    Pozri tiež:
    
    priehľadnosť(), upravPriehľadnosť(double)
  - priehladnost
```
public void priehladnost(Priehľadnosť objekt)
```
    Alias pre priehľadnosť.
  - upravPriehľadnosť
```
public void upravPriehľadnosť(double zmena)
```
    Upraví úroveň (ne)priehľadnosti obráza. Pre viac informácií o priehľadnosti pozri priehľadnosť.
    
    Parametre:
    
    zmena – hodnota, ktorou bude násobená aktuálna hodnota priehľadnosti; príklady: 0.5 – priehľadnosť bude znížená o polovicu, 2.0 – úroveň priehľadnosti bude zdvojnásobená
    
    Pozri tiež:
    
    priehľadnosť(double), priehľadnosť()
  - upravPriehladnost
```
public void upravPriehladnost(double zmena)
```
    Alias pre upravPriehľadnosť.
  - ulož
```
public void ulož(String súbor)
```
    Uloží obrázok do súboru. Prípona súboru musí byť .gif, .png alebo .jpg (resp. .jpeg). Ak súbor jestvuje, tak vznikne výnimka oznamujúca, že súbor so zadaným menom už jestvuje. Ak chcete súbor prepísať, použite metódu ulož(String súbor, boolean prepísať) s druhým parametrom rovným true. Odporúčame pozrieť si opis uvedenej metódy, pretože obsahuje užitočné príklady použitia a informácie v jej opise sú platné aj pre túto metódu.
    
    Parametre:
    
    súbor – názov súboru s požadovanou príponou
    
    Výnimky:
    
    GRobotException – ak súbor jestvuje alebo bol zadaný názov súboru s neplatnou príponou
  - uloz
```
public void uloz(String súbor)
```
    Alias pre ulož.
  - ulož
```
public void ulož(String súbor,
                 boolean prepísať)
```
    Uloží obsah obrázka do súboru. Prípona súboru musí byť .gif, .png alebo .jpg (resp. .jpeg).
    
    Formát GIF je jedným z najstarších z pohľadu histórie grafických formátov, ale stal sa obľúbeným, pretože umožňuje tvoriť animované verzie obrázkov. Ak je inštancia obrázka animovaná, tak táto metóda automaticky vytvorí a uloží animovanú verziu GIFu. Implicitne pri tom použije niektoré jestvujúce vlastnosti/nastavenia/stavy programovacieho rámca, napríklad farba pozadia je zmiešaná so všetkými polopriehľadnými bodmi, pretože formát GIF nepodporuje čiastočnú priehľadnosť bodov a aktuálna hodnota počtu opakovaní animácie zároveň určí počet opakovaní uložený a používaný v tomto súborovom formáte, pričom pri ukladaní má hodnota 0 rovnaký význam ako akákoľvek záporná hodnota, čiže nekonečný počet opakovaní (na rozdiel od významu použitého v programovacom rámci, kedy hodnota 0 znamená koniec animácie a záporné hodnoty znamenajú nekonečný počet opakovaní).
    
    Príklad:
    
    Formát GIF je historickým formátom s určitými (najmä farebnými) obmedzeniami, ale stále nachádza svoje použitie. Nasledujúci príklad ukazuje ako takýto súbor vytvoriť s použitím programovacieho rámca GRobot, ale na plnohodnotné (plnofarebné) uloženie snímok animovaného obrázka odporúčame použiť sekvenciu súborov vo formáte PNG, ktorú táto metóda vytvorí automaticky, ak nájde v názve súboru zástupný znak * – pozri ďalší príklad. (Znak * bol zvolený úmyselne, pretože na nami používaných operačných systémoch ide o neplatný znak v rámci názvov súborov.)
```
import knižnica.*;

public class VytvorAnimovanýGIF extends GRobot
{
    // Inštancia obrázka, do ktorej budú ukladané snímky animácie lopty
    // a ktorá výslednú animáciu uloží do formátu GIF.
    private Obrázok animovanýObrázok;

    // Zoznam modrých farieb použitých na tieňovanie lopty.
    private final Zoznam<Farba> farby = new Zoznam<Farba>(
        new Farba( 0, 0, 224), new Farba(16, 16, 232),
        new Farba(32, 32, 240), new Farba(48, 48, 248),
        new Farba(64, 64, 255));

    // Táto metóda je schopná nakresliť loptu vrátane jej prípadnej
    // deformácie.
    private void kresliLoptu(double sploštenieX, double sploštenieY)
    {
        // Vždy pred kreslením lopty sa aktuálny obsah animovaného obrázka
        // vymaže:
        animovanýObrázok.vymaž();

        // Najprv spracujeme tieňovanie lopty. Na to treba obmedziť oblasť
        // kreslenia do obrázka na požadovaný tvar, čo zariadia nasledujúce
        // tri príkazy:
        nekresliTvary();
        kresliDo(elipsa(40 + sploštenieX, 40 + sploštenieY));
        kresliTvary();

        // Nasledujúci blok kreslí tieňovanie lopty:
        // (Poznámka: Toto by sa dalo riešiť aj náterom.)
        double menej = 0;
        skoč(-12 + sploštenieX, 12 + sploštenieY);
        for (Farba farba : farby)
        {
            farba(farba);
            kruh(60 + menej);
            menej -= 12;
        }
        skoč(12 - sploštenieX, -12 - sploštenieY);

        // Rozmažeme kresbu a zrušíme obmedzenie kreslenia do oblasti:
        animovanýObrázok.rozmaž(12);
        kresliVšade();

        // Na záver prekreslíme obrysy lopty, aby sme trochu zamaskovali
        // nie celkom esteticky rozmazané okraje:
        farba(farby.prvý());
        elipsa(40 + sploštenieX, 40 + sploštenieY);

        farba(farby.daj(1));
        elipsa(40 + sploštenieX - 1.5, 40 + sploštenieY - 1.5);
        elipsa(40 + sploštenieX - 3.0, 40 + sploštenieY - 3.0);
    }

    // Odľahčená verzia metódy kresliaca nedeformovanú loptu.
    private void kresliLoptu()
    {
        kresliLoptu(0, 0);
    }

    // Súkromný konštruktor.
    private VytvorAnimovanýGIF()
    {
        // Rozmer plátna bude o málo väčší oproti rozmeru obrázka:
        super(140, 240);

        // Vypneme automatické prekresľovanie
        Svet.nekresli();

        // Vytvoríme nový obrázok, do ktorého bude ukladaná animácia;
        // určíme, že trvanie zobrazenia každej snímky bude 40 ms
        // a vykonáme nevyhnutné nastavenia robota, čo zahŕňa aj
        // presmerovanie jeho kreslenia do animovaného obrázka:
        animovanýObrázok = new Obrázok(120, 220);
        animovanýObrázok.trvanie(0.040);
        hrúbkaČiary(3);
        kresliDoObrázka(animovanýObrázok);
        zdvihniPero();
        skry();

        // Posunieme robot dozadu (nižšie na obrazovke) a začneme animáciu:
        dozadu(52);

        // Prvá (päťsnímková) fáza animácie deformuje loptu pri dopade:
        for (int i = 0; i <= 4; ++i)
        {
            kresliLoptu(2.0 * i, -2.0 * i);
            dozadu(2.0);
            animovanýObrázok.pridajSnímku();
        }

        // Pri návrate deformovanej lopty do pôvodného tvaru jednu snímku
        // preskočíme…
        dopredu(2.0);

        // …a animujeme už len štyri fázy:
        for (int i = 3; i >= 0; --i)
        {
            kresliLoptu(2.0 * i, -2.0 * i);
            dopredu(2.0);
            animovanýObrázok.pridajSnímku();
        }

        // Ďalšia fáza je výskok lopty do výšky:
        for (int i = 14; i >= 0; --i)
        {
            kresliLoptu();
            dopredu(1.0 * i);
            animovanýObrázok.pridajSnímku();
        }

        // A posledná fáza je jej návrat na zem:
        for (int i = 0; i <= 14; ++i)
        {
            kresliLoptu();
            dozadu(1.0 * i);
            animovanýObrázok.pridajSnímku();
        }

        // Vrátime robot domov, obnovíme mu kreslenie na plátno
        // a uložíme a spustíme animáciu:
        domov();
        kresliNaPodlahu();
        animovanýObrázok.ulož("lopta.gif", true);
        animovanýObrázok.spusti();

        // Spustíme časovač:
        Svet.spustiČasovač(0.020);
    }

    // Reakcia na časovač – pravidelne prekresľuje animovaný obrázok, ktorého
    // animácia je vykonávaná automaticky (vnútornými mechanizmami sveta).
    @Override public void tik()
    {
        if (Svet.neboloPrekreslené())
        {
            podlaha.vymažGrafiku();
            obrázok(animovanýObrázok);
            Svet.prekresli();
        }
    }

    // Hlavná metóda.
    public static void main(String... args)
    {
        // Skrytie sveta (okna aplikácie):
        Svet.skry();

        // Vytvorenie anonymnej inštancie tejto triedy (konštruktor triedy
        // odvodenej od robota vždy zabezpečí vytvorenie aplikácie):
        new VytvorAnimovanýGIF();

        // Automatické nastavenie veľkosti a polohy okna sveta
        // (t. j. aplikácie) a jeho zobrazenie:
        Svet.zbaľ();
        Svet.vystreď();
        Svet.zobraz();
    }
}
```
    Výsledok:
    
    Výsledný obrázok – lopta.gif.
    
    Príklad:
    
    Sekvenciu súborov vo formáte PNG vytvoríte, ak namiesto názvu súboru zadáte šablónu v nasledujúcom tvare (dôležitá je prítomnosť aspoň jednej hviezdičky – zvýraznené červenou):
    
        «prefix»*[«ľubovoľné znaky»*]«postfix».png
    
    Príklady platných šablón a ukážky názvov prvých dvoch a niekoľkých ďalších náhodne zvolených súborov snímok v animovanej sekvencii (ak by animácia mala potrebný rozsah, čo najmä v poslednom prípade hraničí s reálnosťou):
    
        srdce*.png – srdce1.png, srdce2.png… srdce10.png…
    
        lopta-**.png – lopta-01.png, lopta-02.png… lopta-10.png… lopta-102.png…
    
        _algoritmus-****_.png – _algoritmus-0001_.png, _algoritmus-0002_.png… _algoritmus-0010_.png… _algoritmus-0102_.png… _algoritmus-1024_.png… _algoritmus-22800_.png…
    
        Sekvencia_*2345*.PNG – Sekvencia_000001.PNG, Sekvencia_000002.PNG… Sekvencia_000010.PNG… Sekvencia_000102.PNG… Sekvencia_001024.PNG… Sekvencia_022800.PNG… Sekvencia_10000000.PNG…
    
    Na príkladoch je vidieť, že v šablóne je podstatný výskyt prvého a posledného znaku *, pričom môže ísť aj o ten istý znak (ak je jediný). Prípadné znaky medzi nimi sú z pohľadu obsahu ignorované a do úvahy je vzatý len ich celkový počet, ktorý prispeje k určeniu počtu cifier číslovania v názvoch súborov snímok animácie.
    
    Pozor! Ak sa týmto spôsobom pokúsite uložiť obrázok, ktorý nemá definovanú ani jednu snímku animácie, tak táto metóda uloží jediný súbor s poradovým číslom nula a ak je tento súbor nájdený metódou čítaj(súbor) pri pokuse o čítanie sekvencie súborov so zhodnou šablónou, tak ho prečíta ako neanimovaný obrázok a už sa nepokúša hľadať ďalšie súbory vyhovujúce kritériám šablóny názvov súborov animovanej sekvencie.
    
    Poznámka: Od verzie 2.18 sa PNG sekvencie dajú jednoducho zapisovať aj do archívu (ZIP). Výhodou je uchovanie celej animácie v jednom súbore, úspora vnútornej pamäte programovacieho rámca a tiež automatické uchovanie informácií o časovaní snímok (v samostatnej položke archívu). Pozri aj príklad v opise metódy Obrázok.čítaj(archív, názovPoložky).
    
    Podobne funguje komunikácia pri určovaní výsledného počtu snímok ak je druhý parameter tejto metódy (prepísať) rovný true a na pevnom disku jestvuje sekvencia s vyšším alebo nulovým počtom snímok, tak pri zápise táto metóda vymaže súbor s poradovým číslom nula a/alebo súbor s najbližším vyšším poradovým číslom po skončení aktuálnej sekvencie. Tým je zaručené, že metóda čítaj(súbor) prečíta rovnaký počet snímok aký má aktuálna sekvencia.
```
import knižnica.*;

public class VytvorSekvenciuPNG extends GRobot
{
    // Tieto konštanty určia rozmery indikátora stavu zobrazeného
    // a aktualizovaného na obrazovke počas tvorby a zápisu animácie do
    // sekvencie PNG súborov (v skutočnosti ide o polovičné hodnoty):
    private final static double výškaIndikátora = 20.0;
    private final static double šírkaIndikátora = 160.0;

    // Táto konštanta určuje požadovaný počet snímok animácie (ak nie je podiel
    // 360.0 / početSnímok celé číslo, tak sa môže skutočný počet zvýšiť
    // o jednu snímku):
    private final static int početSnímok = 250;

    // Inštancia obrázka, do ktorej budú ukladané snímky vytváranej animácie
    // a ktorá ju uloží do seknvencie PNG súborov:
    private Obrázok animovanýObrázok;
    
    // Kreslenie indikátora priebehu.
    private void kresliIndikátor(double hotovo)
    {
        // Prepočítame percentuálnu hodnotu na počet pixelov:
        hotovo *= šírkaIndikátora;

        // Nastavíme hrúbku čiary tvarov indikátora:
        hrúbkaČiary(3.0);

        // Nakreslenie šedej výplne tej časti indikátora, ktorá reprezentuje
        // nedokončenú časť úlohy:
        farba(šedá);
        vyplňObdĺžnik(šírkaIndikátora, výškaIndikátora);

        // Nakreslenie čierneho obrysu rovnakej časti indikátora:
        farba(čierna);
        kresliObdĺžnik(šírkaIndikátora, výškaIndikátora);

        // Presunutie robota na správne miesto tak, aby bola „dokončená časť“
        // indikátora kreslená presne od ľavého okraja celého indikátora:
        skoč(hotovo - šírkaIndikátora, 0);

        // Nakreslenie zelenej výplne tej časti indikátora, ktorá reprezentuje
        // dokončenú časť úlohy:
        farba(zelená);
        vyplňObdĺžnik(hotovo, výškaIndikátora);

        // Nakreslenie čierneho obrysu rovnakej časti indikátora:
        farba(čierna);
        kresliObdĺžnik(hotovo, výškaIndikátora);
    }

    // Metóda slúžiaca na vytvorenie animácie. Prijíma počet bodov, cez ktoré
    // má prechádzať animovaná krivka a požadovaný počet snímok (na túto
    // hodnotu máme zároveň definovanú konštantu; do tejto metódy ju posielame,
    // aby bola univerzálnejšia – vystrihnuteľná a použiteľná v inej
    // aplikácii).
    private void vytvorAnimáciu(int početBodov, int početSnímok)
    {
        // Pole bodov, cez ktoré prechádza animovaná krivka:
        Bod[] čiara = new Bod[početBodov];

        // Uloženie prvého bodu do poľa (zámerne je umiestnený mimo plátna,
        // aby nebolo vidno začiatok krivky – pôsobilo by to rušivo):
        skočNa(0, -Svet.výška() - 10);
        čiara[0] = poloha();

        // Pridanie požadovaného počtu náhodných bodov
        // (okrem prvého a posledného):
        for (int i = 1; i < početBodov - 1; ++i)
        {
            náhodnáPoloha();
            čiara[i] = poloha();
        }

        // Uloženie posledného bodu do poľa (tiež je umiestnený mimo plátna,
        // aby nebolo vidno koniec krivky):
        skočNa(0, Svet.výška() + 10);
        čiara[početBodov - 1] = poloha();

        // Pole farieb použitých na nakreslenie krivky:
        Farba[] farby = new Farba[početBodov];

        // Stanovenie začiatočnej a koncovej farby krivky:
        Farba prvá = červená;
        Farba posledná = žltá;

        // Vypočítanie farebného prechodu medzi začiatočnou a koncovou farbou
        // s použitím lineárnej interpolácie na jednotlivé farebné zložky
        // (vznikne tým lineárny farebný gradient):
        for (int i = 0; i < početBodov; ++i)
            farby[i] = new Farba(
                (int)Svet.lineárnaInterpolácia(
                    prvá.červená(), posledná.červená(),
                    (double)i / (double)početBodov),
                (int)Svet.lineárnaInterpolácia(
                    prvá.zelená(), posledná.zelená(),
                    (double)i / (double)početBodov),
                (int)Svet.lineárnaInterpolácia(
                    prvá.modrá(), posledná.modrá(),
                    (double)i / (double)početBodov));

        // Vypočítanie uhla, ktorý bude slúžiť ako prírastok riadiaceho uhla
        // animácie. Riadiaci uhol bude nadobúdať hodnoty medzi nulou
        // a tristošesťdesiat stupňami a tento meniaci sa uhol bude postupne
        // určovať počiatočné pootočenie robota kresliaceho krivku v rámci
        // jednotlivých snímok. Okrem tohto parametra sa na animovaných
        // snímkach nemení nič. Zvyšok algoritmu kreslenia krivky je úplne
        // rovnaký – prejsť všetkými bodmi, ktoré boli náhodne zvolené vyššie.
        double prírastok = 360.0 / početSnímok;

        // Výroba jednotlivých snímok animácie:
        for (double uhol = 0.0; uhol < 360.0; uhol += prírastok)
        {
            // Vymazanie aktuálnej snímky:
            animovanýObrázok.vymaž();

            // Zahájenie niekoľkých cyklov kreslenia krivky, počas ktorých
            // bude rozmazávaná a opätovne prekresľovaná:
            for (int j = 0; j < 10; ++j)
            {
                // Presmerujeme kreslenie robota do animovaného obrázka:
                kresliDoObrázka(animovanýObrázok);

                // Nastavíme hrúbku kreslenej čiary:
                hrúbkaČiary(5.0 / (double)(j + 1));

                // Skočíme na začiatok krivky:
                skočNa(čiara[0]);
                farba(farby[0]);
                smer(uhol);

                // Ak na snímke jestvuje kresba krivky (ak toto nie je prvá
                // snímka), tak ju rozmažeme:
                if (0 != j) animovanýObrázok.rozmaž(10, čierna);

                // Nakreslíme farebnú krivku (štruktúra try-catch je
                // potrebná, lebo metóda choďNaPoOblúku môže zlyhať; my však
                // jej prípadné zlyhanie ignorujeme):
                for (int i = 1; i < početBodov; ++i)
                    try
                    {
                        farba(farby[i]);
                        choďNaPoOblúku(čiara[i]);
                    }
                    catch (Exception e)
                    {
                        // (Prípadné chyby ignorujeme…)
                    }

                // Vrátime robot domov, obnovíme mu kreslenie na plátno
                // podlahy:
                domov();
                kresliNaPodlahu();

                // Prekreslíme indikátor:
                kresliIndikátor((0.8 * (uhol +
                    ((prírastok * (double)(j + 1)) / 10.0))) / 360.0);

                // A tiež svet (aby sa zmena indikátora prejavila):
                Svet.prekresli();
            }

            // Tu prekreslíme snímku viac ráz cez seba. Keďže obsahuje mnoho
            // polopriehľadných bodov, má to význam. Výsledkom bude
            // zvýraznenie poloriehľadných bodov, ktoré vznikli pri rozmazaní.
            for (int i = 0; i < 2; ++i)
                animovanýObrázok.kresli(animovanýObrázok);

            // Pridáme snímku do animovaného obrázka:
            animovanýObrázok.pridajSnímku();
        }
    }

    // Súkromný konštruktor.
    private VytvorSekvenciuPNG()
    {
        // Upravíme rozmer plátna (ktorý zároveň určí rozmer obrázka):
        super(640, 480);

        // Skryjeme robot:
        skry();

        // Vypneme automatické prekresľovanie:
        Svet.nekresli();

        // Automatické nastavenie veľkosti a polohy okna sveta
        // (t. j. aplikácie) a jeho zobrazenie:
        Svet.zbaľ();
        Svet.vystreď();

        // Vytvoríme nový obrázok, do ktorého bude ukladaná animácia:
        animovanýObrázok = new Obrázok(Svet.šírka(), Svet.výška());

        // Určíme, že trvanie zobrazenia každej snímky bude 40 ms:
        animovanýObrázok.trvanie(0.040);

        // Nakreslíme počiatočný stav indikátora (prázdny):
        kresliIndikátor(0.0);

        // Prekreslíme svet, aby sa indikátor zobrazil používateľovi:
        Svet.prekresli();

        // Spustíme časomieru, pretože sme zvedaví ako dlho bude trvať
        // generovanie animácie:
        Svet.spustiČasomieru();

        // Spustíme výrobu animácie:
        vytvorAnimáciu(50, početSnímok);

        // Zastavíme časomieru a necháme výsledok vypísať na konzolu
        // (výpis sa zobrazí v okne terminálu BlueJa):
        double čas = Svet.zastavČasomieru();
        System.out.println("Tvorba animácie trvala: " +
            Math.round(čas / 60) + " min " + F(čas % 60, 2) + " s");

        // Opäť spustíme časomieru, lebo sme zvedaví ako dlho bude trvať
        // ukladanie PNG sekvencie:
        Svet.spustiČasomieru();

        // Vytvoríme priečinok, do ktorého bude sekvencia ukladaná:
        Súbor.novýPriečinok("sekvencia");

        // Uložíme sekvenciu obrázkov podľa šablóny (šablóna obsahuje názov
        // podpriečinka „sekvencia“):
        animovanýObrázok.ulož("sekvencia/nahodne-ciary-***.png", true);

        // Opäť zastavíme časomieru a vypíšeme výsledok (tiež na konzolu):
        čas = Svet.zastavČasomieru();
        System.out.println("Vytváranie sekvencie súborov trvalo: " +
            Math.round(čas / 60) + " min " + F(čas % 60, 2) + " s");

        // Možno je to pre niekoho zbytočné, ale nakoniec nakreslíme
        // indikátor v úplne dokončenom stave (ak by náhodou zopár
        // nasledujúcich príkazov trvalo dlhšie):
        podlaha.vymažGrafiku();
        kresliIndikátor(1.0);
        Svet.prekresli();

        // Vrátime robot domov, aby bola animácia kreslená korektne:
        domov();

        // A spustíme animáciu aj časovač:
        animovanýObrázok.spusti();
        Svet.spustiČasovač(0.040);

        // Na záver nastavíme čiernu farbu pozadia:
        Svet.farbaPozadia(čierna);
    }

    // Táto reakcia je automaticky spúšťaná počas zápisu (alebo čítania)
    // animovanej PNG sekvencie. Používame ju na aktualizovanie informácie
    // o stave zápisu zobrazenej na obrazovke pre používateľa.
    @Override public void sekvencia(int kódSpracovania, String zdroj,
        String cieľ, long stav, long celkovo)
    {
        // Pred každým kreslení indikátora vymažeme grafiku podlahy
        // a vrátime robot domov:
        podlaha.vymažGrafiku();
        domov();

        // Vypočítame percento dokončenia s tým, že 80 % bolo vykonaných
        // pri tvorbe animácie, takže teraz zobrazujeme už len priebeh zvyšných
        // 20 %:
        kresliIndikátor(0.8 + ((0.2 * (double)stav) / (double)celkovo));

        // Prekreslíme obrazovku:
        Svet.prekresli();
    }

    // Reakcia na časovač – pravidelne prekresľuje animovaný obrázok, ktorého
    // animácia je vykonávaná automaticky (vnútornými mechanizmami sveta).
    @Override public void tik()
    {
        if (Svet.neboloPrekreslené())
        {
            podlaha.vymažGrafiku();
            obrázok(animovanýObrázok);
            Svet.prekresli();
        }
    }

    // Hlavná metóda.
    public static void main(String... args)
    {
        // Vytvorenie anonymnej inštancie tejto triedy (konštruktor triedy
        // odvodenej od robota vždy zabezpečí vytvorenie aplikácie):
        new VytvorSekvenciuPNG();
    }
}
```
    Opis priebehu a výsledku:
    
    Počas tvorby animácie bude v okne sveta aktualizovaný grafický ukazovateľ stavu činnosti:
    
    Grafický ukazovateľ stavu činnosti.
    
    Kód spracovania reakcie sekvencia sme v príklade nepoužili. V tomto prípade mal hodnotu konštanty ZÁPIS_PNG_SEKVENCIE. (V prípade ukladania animáce do formátu GIF je hodnota rovná hodnote konštanty ZÁPIS_GIF_ANIMÁCIE.)
    
    Podľa nami nameraných hodnôt trvalo vytváranie sekvencie od štyroch do šesť a pol minúty. Po skončení fázy generovania (80 % ukazovateľa) pokračuje aplikácia fázou ukladania sekvencie do súboru (zvyšných 20 % ukazovateľa). Podľa nami nameraných hodnôt trvalo ukladanie sekvencie asi minútu a štyridsať sekúnd (s rozptylom desať sekúnd).
    
    Výsledkom vykonania tohto príkladu bude sekvencia súborov vo formáte PNG vytvorená na disku v priečinku sekvencie. Prvý súbor bude mať názov nahodne-ciary-001.png a posledný nahodne-ciary-251.png.
    
    Po dokončení bude v okne aplikácie spustená vytvorená animácia.
    
    Ukážky možného vzhľadu vytvorenej animáce – výsledok každého generovania je unikátny (plátno ukážok je úmyselne zmenšené).
    
    Na 32-bitových operačných systémoch sa môže stať, že aplikácia nebude mať dostatok pamäte na vykonanie. V takom prípade skúste cez príkazový riadok operačného systému spustiť aplikáciu nasledujúcim príkazom potvrdeným v priečinku s preloženou aplikáciou:
```
java -Xmx1g VytvorSekvenciuPNG
```
    Parametre:
    
    súbor – názov súboru s požadovanou príponou
    
    prepísať – ak je true, prípadný jestvujúci súbor bude prepísaný, inak sa správa rovnako ako metóda ulož(String súbor)
    
    Výnimky:
    
    GRobotException – ak súbor jestvuje a parameter prepísať je false alebo ak bol zadaný názov súboru s neplatnou príponou
  - uloz
```
public void uloz(String súbor,
                 boolean prepísať)
```
    Alias pre ulož.
  - ulož
```
public knižnica.apacheAntZIP.ZipEntry[] ulož(Archív archív,
                                             String názovPoložky)
```
    Uloží obsah obrázka do archívu ako položku so zadaným názvom. Archív musí byť vopred otvorený na zápis. Ak je názov položky šablóna PNG sekvencie, tak bude do archívu pridaných toľko položiek, koľko by bolo vytvorených súborov sekvencie, pričom ich názvy budú korešpondovať s názvami súborov sekvencie. Ďalej pre túto metódu platí súhrn relevantných informácií uvedených v opisoch nasledujúcich dvoch metód:
    - ulož(súbor, prepísať);
    - Archív.pridajPoložku(názovPoložky, údajePoložky).
    Upozornenie: Táto metóda je použiteľná len v prípade, že je archív otvorený na zápis.
    
    Pozri aj príklad v opise metódy Obrázok.čítaj(archív, názovPoložky).
    Parametre:
    
    archív – inštancia archívu, do ktorého má byť tento obrázok pridaný ako položka
    
    názovPoložky – názov položky v archíve alebo šablóna názvov položiek, ak chceme zapísať PNG sekvenciu animácie
    
    Návratová hodnota:
    
    položky archívu knižnice Apache Ant ZipEntry na vykonanie prípadných ďalších úprav (nastavenie komentárov položiek, úprava ich dátumu podľa vlastných potrieb a podobne)
    
    Výnimky:
    
    GRobotException – ak bol zadaný názov súboru s neplatnou príponou, ak archív nie je otvorený na zápis, ak bol názov položky zamlčaný (bola zadaná hodnota null) alebo v prípade pokusu o vloženie duplicitnej položky
    
    Pozri tiež:
    
    čítaj(Archív, String), Archív.obrázok(String), Archív.pridajPoložku(String, Obrázok)
  - uloz
```
public knižnica.apacheAntZIP.ZipEntry[] uloz(Archív archív,
                                             String názovPoložky)
```
    Alias pre ulož.
  - doSchránky
```
public boolean doSchránky()
```
    Vloží obsah tohto obrázka do schránky.
    
    Upozornenie: Obrázok je uchovaný v schránke len počas činnosti aplikácie robota. Po zatvorení okna sveta, je obrázok zo schránky odstránený.
    
    Návratová hodnota:
    
    true ak bola operácia úspešná
    
    Pozri tiež:
    
    Schránka.obrázok(Image)
  - doSchranky
```
public boolean doSchranky()
```
    Alias pre doSchránky.
  - porovnaj
```
public static boolean porovnaj(Image obrázok1,
                               Image obrázok2)
```
    Porovná obsahy dvoch zadaných inštancií obrázkov. V prípade, že sú oba argumenty tejto metódy tým istým obrázkom, tak je bez ďalšej kontroly vrátená hodnota true. Ak ide o rôzne objekty obrázkov, tak bude overená zhoda ich obsahu. Najskôr sú porovnané rozmery obrázkov a ak sú zhodné, tak sú porovnané ich rastre. Potom je podľa toho, či sú obsahovo zhodné alebo nie, vrátená hodnota true alebo false.
    
    Parametre:
    
    obrázok1 – prvý porovnávaný obrázok
    
    obrázok2 – druhý porovnávaný obrázok
    
    Návratová hodnota:
    
    ak sú obrázky zhodné, tak true, inak false
  - porovnaj
```
public boolean porovnaj(Image inýObrázok)
```
    Porovná obsah tejto a zadanej inštancie obrázka. Najskôr sú overené rozmery obrázkov a ak sú zhodné, tak sú porovnané ich rastre a podľa toho, či sú obsahovo zhodné alebo nie, je vrátená hodnota true alebo false.
    
    Parametre:
    
    inýObrázok – obrázok, s ktorým je porovnávaný obsah tejto inštancie
    
    Návratová hodnota:
    
    ak je obsah tohto a iného obrázka zhodný, tak true, inak false
  - máVlnenie
```
public boolean máVlnenie()
```
    Overí, či je definovaná inštancia vlnenia pre tento obrázok.
    
    Návratová hodnota:
    
    true ak je inštancia vlnenia definovaná; false v opačnom prípade
    
    Pozri tiež:
    
    vlnenie(), jestvujúceVlnenie(), pridajVlnenie(), pridajVlnenie(boolean), pridajVlnenie(int), pridajVlnenie(int, boolean), odstráňVlnenie()
  - maVlnenie
```
public boolean maVlnenie()
```
    Alias pre máVlnenie.
  - vlnenie
```
public Vlnenie vlnenie()
```
    Vráti inštanciu vlnenia pre tento obrázok, aby bolo možné s vlnením ďalej pracovať. Ak vlnenie nie je pre tento obrázok definované, tak metóda definuje nové neaktívne vlnenie s predvolenou úrovňou útlmu 26. (Overiť to, či je definovaná inštancia vlnenia, je možné pomocou metódy máVlnenie.) Naopak, metóda jestvujúceVlnenie vráti inštanciu vlnenia len v takom prípade, že jestvuje. (V opačnom prípade vráti metóda jestvujúceVlnenie hodnotu null.)
    
    Poznámka: Aby mohlo byť vlnenie automaticky vykonávané, tak v prípade vytvorenia novej inštancie ju táto metóda automaticky registruje vo svete grafického robota.
    
    Upozornenie: Ak svet grafického robota nemá aktívny časovač, tak vlnenie nebude fungovať ani po jeho aktivácii. Táto metóda nespúšťa časovač (ani vlnenie) automaticky! Účelom automatického vytvorenia inštancie vlnenia touto metódou v prípade jej neprítomnosti je len zabránenie vzniku chýb. Táto metóda nemá nahradiť metódu pridajVlnenie.
    
    Návratová hodnota:
    
    metóda zaručuje vrátenie inštancie Vlnenie definovanej pre tento obrázok aj v takom prípade, že pred jej volaním nebola inštancia definovaná
    
    Pozri tiež:
    
    máVlnenie(), jestvujúceVlnenie(), pridajVlnenie(), pridajVlnenie(boolean), pridajVlnenie(int), pridajVlnenie(int, boolean), odstráňVlnenie()
  - jestvujúceVlnenie
```
public Vlnenie jestvujúceVlnenie()
```
    Táto metóda vráti inštanciu vlnenia len v prípade, že jestvuje. V opačnom prípade vráti hodnotu null, čo môže viesť ku vzniku výnimky, ak sa programátor pokúsi použiť vrátenú hodnotu bez overenia. Naopak, vrátenie inštancie vlnenia aj v prípade, že ešte nebolo definované zaručuje metóda vlnenie.
    
    Návratová hodnota:
    
    ak je definovaná inštancia vlnenia, tak ju metóda vráti; v opačnom prípade vráti hodnotu null
    
    Pozri tiež:
    
    máVlnenie(), vlnenie(), pridajVlnenie(), pridajVlnenie(boolean), pridajVlnenie(int), pridajVlnenie(int, boolean), odstráňVlnenie()
  - jestvujuceVlnenie
```
public Vlnenie jestvujuceVlnenie()
```
    Alias pre jestvujúceVlnenie.
  - existujúceVlnenie
```
public Vlnenie existujúceVlnenie()
```
    Alias pre jestvujúceVlnenie.
  - existujuceVlnenie
```
public Vlnenie existujuceVlnenie()
```
    Alias pre jestvujúceVlnenie.
  - definovanéVlnenie
```
public Vlnenie definovanéVlnenie()
```
    Alias pre jestvujúceVlnenie.
  - definovaneVlnenie
```
public Vlnenie definovaneVlnenie()
```
    Alias pre jestvujúceVlnenie.
  - pridajVlnenie
```
public void pridajVlnenie()
```
    Pridá alebo zresetuje vlnenie tohto obrázka. Ak nie je definované alebo aktívne vlnenie pre tento obrázok, tak volanie tejto metódy vytvorí a/alebo aktivuje novú inštanciu vlnenia s predvolenou úrovňou útlmu 26.
    
    Poznámka: Aby mohlo byť vlnenie automaticky vykonávané, tak v prípade vytvorenia novej inštancie ju táto metóda automaticky registruje vo svete grafického robota.
    
    Ak by svet grafického robota nemal aktívny časovač, tak by vlnenie nemohlo fungovať, preto je časovač touto metódou spúšťaný automaticky.
    
    Inštanciu vlnenia je možné získať a pracovať s ňou pomocou metódy vlnenie alebo jestvujúceVlnenie.
    
    Pozor! Ak vlnenie nie je definované, tak metóda vlnenie definuje nové neaktívne vlnenie s predvolenou úrovňou útlmu 26. Overiť to, či je definovaná inštancia vlnenia, je možné pomocou metódy máVlnenie. Metóda jestvujúceVlnenie vráti inštanciu vlnenia len v prípade, že jestvuje. V opačnom prípade vráti hodnotu null, čo môže viesť ku vzniku výnimky, ak sa programátor pokúsi použiť vrátenú hodnotu bez overenia.
    
    Ak už je definovaná inštancia vlnenia, tak ju volanie tejto metódy zresetuje upokojením hladiny a nastavením predvolenej úrovne útlmu 26. (Aktivácia je vykonaná v každom prípade.)
    
    Pozri tiež:
    
    máVlnenie(), vlnenie(), jestvujúceVlnenie(), pridajVlnenie(boolean), pridajVlnenie(int), pridajVlnenie(int, boolean), odstráňVlnenie()
  - pridajVlnenie
```
public void pridajVlnenie(boolean ajČasovač)
```
    Pridá alebo zresetuje vlnenie tohto obrázka. Ak nie je definované alebo aktívne vlnenie pre tento obrázok, tak volanie tejto metódy vytvorí a/alebo aktivuje novú inštanciu vlnenia s predvolenou úrovňou útlmu 26.
    
    Poznámka: Aby mohlo byť vlnenie automaticky vykonávané, tak v prípade vytvorenia novej inštancie ju táto metóda automaticky registruje vo svete grafického robota.
    
    Pozor! Ak svet grafického robota nemá aktívny časovač, tak vlnenie nebude fungovať. Táto metóda dovoľuje určiť, či má alebo nemá byť časovač spustený automaticky. Umožňuje to parameter ajČasovač.
    
    Inštanciu vlnenia je možné získať a pracovať s ňou pomocou metódy vlnenie alebo jestvujúceVlnenie.
    
    Pozor! Ak vlnenie nie je definované, tak metóda vlnenie definuje nové neaktívne vlnenie s predvolenou úrovňou útlmu 26. Overiť to, či je definovaná inštancia vlnenia, je možné pomocou metódy máVlnenie. Metóda jestvujúceVlnenie vráti inštanciu vlnenia len v prípade, že jestvuje. V opačnom prípade vráti hodnotu null, čo môže viesť ku vzniku výnimky, ak sa programátor pokúsi použiť vrátenú hodnotu bez overenia.
    
    Ak už je definovaná inštancia vlnenia, tak ju volanie tejto metódy zresetuje upokojením hladiny a nastavením predvolenej úrovne útlmu 26. (Aktivácia je vykonaná v každom prípade.)
    
    Parametre:
    
    ajČasovač – ak je hodnota tohto parametra rovná true, tak je v prípade jeho nečinnosti automaticky spustený časovač
    
    Pozri tiež:
    
    máVlnenie(), vlnenie(), jestvujúceVlnenie(), pridajVlnenie(), pridajVlnenie(int), pridajVlnenie(int, boolean), odstráňVlnenie()
  - pridajVlnenie
```
public void pridajVlnenie(int útlm)
```
    Pridá alebo zresetuje vlnenie tohto obrázka. Ak nie je definované alebo aktívne vlnenie pre tento obrázok, tak volanie tejto metódy vytvorí a/alebo aktivuje novú inštanciu vlnenia so zadanou úrovňou útlmu (pozri aj Vlnenie.útlm(útlm)).
    
    Poznámka: Aby mohlo byť vlnenie automaticky vykonávané, tak v prípade vytvorenia novej inštancie ju táto metóda automaticky registruje vo svete grafického robota.
    
    Ak by svet grafického robota nemal aktívny časovač, tak by vlnenie nemohlo fungovať, preto je časovač touto metódou spúšťaný automaticky.
    
    Inštanciu vlnenia je možné získať a pracovať s ňou pomocou metódy vlnenie alebo jestvujúceVlnenie.
    
    Pozor! Ak vlnenie nie je definované, tak metóda vlnenie definuje nové neaktívne vlnenie s predvolenou úrovňou útlmu 26. Overiť to, či je definovaná inštancia vlnenia, je možné pomocou metódy máVlnenie. Metóda jestvujúceVlnenie vráti inštanciu vlnenia len v prípade, že jestvuje. V opačnom prípade vráti hodnotu null, čo môže viesť ku vzniku výnimky, ak sa programátor pokúsi použiť vrátenú hodnotu bez overenia.
    
    Ak už je definovaná inštancia vlnenia, tak ju volanie tejto metódy zresetuje upokojením hladiny a nastavením zadanej úrovne útlmu. (Aktivácia je vykonaná v každom prípade.)
    
    Parametre:
    
    útlm – požadovaná úroveň útlmu vlnenia; odporúčané sú hodnoty v rozmedzí 0 – 30; pozri aj Vlnenie.útlm(útlm)
    
    Pozri tiež:
    
    máVlnenie(), vlnenie(), jestvujúceVlnenie(), pridajVlnenie(), pridajVlnenie(boolean), pridajVlnenie(int, boolean), odstráňVlnenie(), Vlnenie.útlm(int)
  - pridajVlnenie
```
public void pridajVlnenie(int útlm,
                          boolean ajČasovač)
```
    Pridá alebo zresetuje vlnenie tohto obrázka. Ak nie je definované alebo aktívne vlnenie pre tento obrázok, tak volanie tejto metódy vytvorí a/alebo aktivuje novú inštanciu vlnenia so zadanou úrovňou útlmu (pozri aj Vlnenie.útlm(útlm)).
    
    Poznámka: Aby mohlo byť vlnenie automaticky vykonávané, tak v prípade vytvorenia novej inštancie ju táto metóda automaticky registruje vo svete grafického robota.
    
    Pozor! Ak svet grafického robota nemá aktívny časovač, tak vlnenie nebude fungovať. Táto metóda dovoľuje určiť, či má alebo nemá byť časovač spustený automaticky. Umožňuje to parameter ajČasovač.
    
    Inštanciu vlnenia je možné získať a pracovať s ňou pomocou metódy vlnenie alebo jestvujúceVlnenie.
    
    Pozor! Ak vlnenie nie je definované, tak metóda vlnenie definuje nové neaktívne vlnenie s predvolenou úrovňou útlmu 26. Overiť to, či je definovaná inštancia vlnenia, je možné pomocou metódy máVlnenie. Metóda jestvujúceVlnenie vráti inštanciu vlnenia len v prípade, že jestvuje. V opačnom prípade vráti hodnotu null, čo môže viesť ku vzniku výnimky, ak sa programátor pokúsi použiť vrátenú hodnotu bez overenia.
    
    Ak už je definovaná inštancia vlnenia, tak ju volanie tejto metódy zresetuje upokojením hladiny a nastavením zadanej úrovne útlmu. (Aktivácia je vykonaná v každom prípade.)
    
    Parametre:
    
    útlm – požadovaná úroveň útlmu vlnenia; odporúčané sú hodnoty v rozmedzí 0 – 30; pozri aj Vlnenie.útlm(útlm)
    
    ajČasovač – ak je hodnota tohto parametra rovná true, tak je v prípade jeho nečinnosti automaticky spustený časovač
    
    Pozri tiež:
    
    máVlnenie(), vlnenie(), jestvujúceVlnenie(), pridajVlnenie(), pridajVlnenie(boolean), pridajVlnenie(int), odstráňVlnenie(), Vlnenie.útlm(int)
  - odstráňVlnenie
```
public void odstráňVlnenie()
```
    Ukončí vlnenie a úplne odstráni inštanciu vlnenia tohto obrázka z prostredia programovacieho rámca GRobot.
    
    Pozri tiež:
    
    máVlnenie(), vlnenie(), jestvujúceVlnenie(), pridajVlnenie(), pridajVlnenie(boolean), pridajVlnenie(int), pridajVlnenie(int, boolean)
  - odstranVlnenie
```
public void odstranVlnenie()
```
    Alias pre odstráňVlnenie.
  - rýchlosť
```
public double rýchlosť()
```
    Vráti aktuálnu rýchlosť prehrávania animácie (bez ohľadu na to, či je práve animácia spustená alebo nie). Rýchlosť je vyjadrená pomerne. Hodnota 1.0 znamená skutočnú rýchlosť určenú hodnotami trvania zobrazenia snímok animácie, 2.0 znamená dvojnásobnú rýchlosť a tak podobne. Záporná hodnota znamená, že animácia je prehrávaná pospiatku.
    
    Návratová hodnota:
    
    aktuálna rýchlosť prehrávania animácie
  - rychlost
```
public double rychlost()
```
    Alias pre rýchlosť.
  - rýchlosťAnimácie
```
public double rýchlosťAnimácie()
```
    Vráti aktuálnu rýchlosť prehrávania animácie (bez ohľadu na to, či je práve animácia spustená alebo nie). Rýchlosť je vyjadrená pomerne. Hodnota 1.0 znamená skutočnú rýchlosť určenú hodnotami trvania zobrazenia snímok animácie, 2.0 znamená dvojnásobnú rýchlosť a tak podobne. Záporná hodnota znamená, že animácia je prehrávaná pospiatku.
    
    Návratová hodnota:
    
    aktuálna rýchlosť prehrávania animácie
  - rychlostAnimacie
```
public double rychlostAnimacie()
```
    Alias pre rýchlosťAnimácie.
  - rýchlosť
```
public void rýchlosť(double nováRýchlosť)
```
    Upraví rýchlosť prehrávania animácie (bez ohľadu na to, či je práve animácia spustená alebo nie). Rýchlosť je vyjadrená pomerne. Hodnota 1.0 znamená skutočnú rýchlosť určenú hodnotami trvania zobrazenia snímok animácie, 2.0 znamená dvojnásobnú rýchlosť a tak podobne. Záporná hodnota znamená, že animácia bude prehrávaná pospiatku a nula znamená, že animácia má byť zastavená (pričom pôvodná rýchlosť prehrávania nebude zmenená).
    
    Parametre:
    
    nováRýchlosť – nová rýchlosť animácie; záporná hodnota znamená smer prehrávania animácie pospiatku; nulová hodnota nezmení skutočnú rýchlosť prehrávania, ale len zastaví vykonávanie animácie (ak prebiehalo)
  - rychlost
```
public void rychlost(double nováRýchlosť)
```
    Alias pre rýchlosť.
  - rýchlosťAnimácie
```
public void rýchlosťAnimácie(double nováRýchlosť)
```
    Upraví rýchlosť prehrávania animácie (bez ohľadu na to, či je práve animácia spustená alebo nie). Rýchlosť je vyjadrená pomerne. Hodnota 1.0 znamená skutočnú rýchlosť určenú hodnotami trvania zobrazenia snímok animácie, 2.0 znamená dvojnásobnú rýchlosť a tak podobne. Záporná hodnota znamená, že animácia bude prehrávaná pospiatku a nula znamená, že animácia má byť zastavená (pričom pôvodná rýchlosť prehrávania nebude zmenená).
    
    Parametre:
    
    nováRýchlosť – nová rýchlosť animácie; záporná hodnota znamená smer prehrávania animácie pospiatku; nulová hodnota nezmení skutočnú rýchlosť prehrávania, ale len zastaví vykonávanie animácie (ak prebiehalo)
  - rychlostAnimacie
```
public void rychlostAnimacie(double nováRýchlosť)
```
    Alias pre rýchlosťAnimácie.
  - početSnímok
```
public int početSnímok()
```
    Vráti aktuálny počet snímok animácie uloženej v tomto obrázku. Nula znamená, že tento obrázok nie je animovaný.
    
    Každá nová snímka je vnútorne reprezentovaná ako samostatná kópia grafickej informácie obrázka, ktorá môže byť prenesená z alebo do hlavnej grafiky obrázka. Tento proces prenosu môže byť jednostranný (počas animácie) alebo obojstranný (pri zmene snímky alebo pri ukladaní alebo čítaní obrázka zo súboru). To znamená, že ak nie je spustená animácia, tak sa medzi snímkami môžeme posúvať metódami prváSnímka, ďalšiaSnímka, predchádzajúcaSnímka, predchádzajúcaSnímka a snímka(ktorá) a vtedy je zaručené, že sa pri posune medzi snímkami zároveň stihnú aktualizovať grafické informácie, ktoré boli medzičasom vykonané v hlavnej grafike obrázka. Naopak, ak je animácia spustená, môže kedykoľvek nastať prepísanie hlavnej grafiky grafikou niektorej snímky a prípadné zmeny sa nemusia stihnúť uložiť. Počas procesu animácie (ktorý je automaticky vykonávaný na pozadí) sa totiž údaje z hlavnej grafiky z optimalizačných dôvodov neuchovávajú späť do snímok.
    
    Návratová hodnota:
    
    aktuálny počet snímok animácie uložených v tomto obrázku
  - pocetSnimok
```
public int pocetSnimok()
```
    Alias pre početSnímok.
  - pridajSnímku
```
public void pridajSnímku()
```
    Pridá novú snímku na koniec animácie s aktuálnou (naposledy použitou) hodnotou trvania zobrazenia a s aktuálnou grafikou obrázka.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok.
  - pridajSnimku
```
public void pridajSnimku()
```
    Alias pre pridajSnímku.
  - pridajSnímku
```
public void pridajSnímku(Image obrázok)
```
    Pridá novú snímku na koniec animácie s aktuálnou (naposledy použitou) hodnotou trvania zobrazenia a so zadanou grafikou.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok.
    
    Parametre:
    
    obrázok – grafika novej snímky
  - pridajSnimku
```
public void pridajSnimku(Image obrázok)
```
    Alias pre pridajSnímku.
  - pridajSnímku
```
public void pridajSnímku(Image obrázok,
                         double trvanie)
```
    Pridá novú snímku na koniec animácie so zadanou grafikou a so zadanou hodnotou trvania jej zobrazenia.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok.
    
    Parametre:
    
    obrázok – grafika novej snímky
    
    trvanie – čas zobrazenia snímky v sekundách s presnosťou na tisíciny
  - pridajSnimku
```
public void pridajSnimku(Image obrázok,
                         double trvanie)
```
    Alias pre pridajSnímku.
  - vložSnímku
```
public void vložSnímku(int indexSnímky)
```
    Vloží novú snímku animácie na zadanú pozíciu s aktuálnou (naposledy použitou) hodnotou trvania zobrazenia a s aktuálnou grafikou obrázka.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok.
    
    Parametre:
    
    indexSnímky – index cieľovej snímky; platí to, čo pri všetkých metódach pracujúcich s indexmi snímok – ak je táto hodnota väčšia alebo rovná než je aktuálny počet snímok, tak bude prepočítaná tak, aby ukazovala na adekvátne vzdialenú snímku v rámci cyklickej animácie (čiže hodnota rovná počtu snímok bude presmerovaná na prvú snímku – s indexom nula, hodnota o jedno vyššia na druhú – s indexom dva a tak ďalej); záporné hodnoty budú prepočítané v opačnom smere (od konca animácie)
  - vlozSnimku
```
public void vlozSnimku(int indexSnímky)
```
    Alias pre vložSnímku.
  - vložSnímku
```
public void vložSnímku(int indexSnímky,
                       Image obrázok)
```
    Vloží novú snímku animácie na zadanú pozíciu s aktuálnou (naposledy použitou) hodnotou trvania zobrazenia a so zadanou grafikou.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok.
    
    Parametre:
    
    indexSnímky – index cieľovej snímky; platí to, čo pri všetkých metódach pracujúcich s indexmi snímok – ak je táto hodnota väčšia alebo rovná než je aktuálny počet snímok, tak bude prepočítaná tak, aby ukazovala na adekvátne vzdialenú snímku v rámci cyklickej animácie (čiže hodnota rovná počtu snímok bude presmerovaná na prvú snímku – s indexom nula, hodnota o jedno vyššia na druhú – s indexom dva a tak ďalej); záporné hodnoty budú prepočítané v opačnom smere (od konca animácie)
    
    obrázok – grafika novej snímky
  - vlozSnimku
```
public void vlozSnimku(int indexSnímky,
                       Image obrázok)
```
    Alias pre vložSnímku.
  - vložSnímku
```
public void vložSnímku(int indexSnímky,
                       Image obrázok,
                       double trvanie)
```
    Vloží novú snímku animácie na zadanú pozíciu so zadanou grafikou a so zadanou hodnotou trvania jej zobrazenia.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok.
    
    Parametre:
    
    indexSnímky – index cieľovej snímky; platí to, čo pri všetkých metódach pracujúcich s indexmi snímok – ak je táto hodnota väčšia alebo rovná než je aktuálny počet snímok, tak bude prepočítaná tak, aby ukazovala na adekvátne vzdialenú snímku v rámci cyklickej animácie (čiže hodnota rovná počtu snímok bude presmerovaná na prvú snímku – s indexom nula, hodnota o jedno vyššia na druhú – s indexom dva a tak ďalej); záporné hodnoty budú prepočítané v opačnom smere (od konca animácie)
    
    obrázok – grafika novej snímky
    
    trvanie – čas zobrazenia snímky v sekundách s presnosťou na tisíciny
  - vlozSnimku
```
public void vlozSnimku(int indexSnímky,
                       Image obrázok,
                       double trvanie)
```
    Alias pre vložSnímku.
  - vymažSnímku
```
public void vymažSnímku()
```
    Vymaže aktuálnu snímku animácie a aktivuje najbližšiu dostupnú snímku. Ak to bola posledná snímka v obrázku, tak zostane nastavená jej grafika a prípadná prebiehajúca animácia sa zastaví.
  - vymazSnimku
```
public void vymazSnimku()
```
    Alias pre vymažSnímku.
  - vymažSnímku
```
public void vymažSnímku(int indexSnímky)
```
    Vymaže zadanú snímku animácie a ak to bola aktívna snímka, tak aktivuje najbližšiu dostupnú snímku. Ak to bola posledná zostávajúca snímka v tomto obrázku, tak zostane nastavená jej grafika a prípadná prebiehajúca animácia sa zastaví.
    
    Parametre:
    
    indexSnímky – index cieľovej snímky; platí to, čo pri všetkých metódach pracujúcich s indexmi snímok – ak je táto hodnota väčšia alebo rovná než je aktuálny počet snímok, tak bude prepočítaná tak, aby ukazovala na adekvátne vzdialenú snímku v rámci cyklickej animácie (čiže hodnota rovná počtu snímok bude presmerovaná na prvú snímku – s indexom nula, hodnota o jedno vyššia na druhú – s indexom dva a tak ďalej); záporné hodnoty budú prepočítané v opačnom smere (od konca animácie)
  - vymazSnimku
```
public void vymazSnimku(int indexSnímky)
```
    Alias pre vymažSnímku.
  - ďalšiaSnímka
```
public void ďalšiaSnímka()
```
    Aktivuje nasledujúcu snímku animácie.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok.
  - dalsiaSnimka
```
public void dalsiaSnimka()
```
    Alias pre ďalšiaSnímka.
  - predchádzajúcaSnímka
```
public void predchádzajúcaSnímka()
```
    Aktivuje predchádzajúcu snímku animácie.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok.
  - predchadzajucaSnimka
```
public void predchadzajucaSnimka()
```
    Alias pre predchádzajúcaSnímka.
  - prváSnímka
```
public void prváSnímka()
```
    Aktivuje prvú snímku animácie.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok.
  - prvaSnimka
```
public void prvaSnimka()
```
    Alias pre prváSnímka.
  - poslednáSnímka
```
public void poslednáSnímka()
```
    Aktivuje poslednú snímku animácie.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok.
  - poslednaSnimka
```
public void poslednaSnimka()
```
    Alias pre poslednáSnímka.
  - snímka
```
public void snímka(int indexSnímky)
```
    Aktivuje zadanú snímku animácie.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok.
    
    Parametre:
    
    indexSnímky – index cieľovej snímky; platí to, čo pri všetkých metódach pracujúcich s indexmi snímok – ak je táto hodnota väčšia alebo rovná než je aktuálny počet snímok, tak bude prepočítaná tak, aby ukazovala na adekvátne vzdialenú snímku v rámci cyklickej animácie (čiže hodnota rovná počtu snímok bude presmerovaná na prvú snímku – s indexom nula, hodnota o jedno vyššia na druhú – s indexom dva a tak ďalej); záporné hodnoty budú prepočítané v opačnom smere (od konca animácie)
  - snimka
```
public void snimka(int indexSnímky)
```
    Alias pre snímka.
  - snímka
```
public int snímka()
```
    Vráti index aktívnej snímky animácie.
    
    Návratová hodnota:
    
    index aktívnej (aktuálne zvolenej) snímky animácie
  - snimka
```
public int snimka()
```
    Alias pre snímka.
  - trvanie
```
public double trvanie()
```
    Zistí hodnotu trvania zobrazenia aktívnej snímky. (Prípadne aktuálnu naposledy použitú hodnotu trvania, ak animácia nemá žiadne snímky.)
    
    Návratová hodnota:
    
    trvanie zobrazenia aktívnej snímky počas animácie v sekundách s presnosťou na tisíciny (pri jednotkovej rýchlosti prehrávania)
  - trvanie
```
public double trvanie(int indexSnímky)
```
    Zistí hodnotu trvania zobrazenia zadanej snímky. (Prípadne aktuálnu naposledy použitú hodnotu trvania, ak animácia nemá žiadne snímky.)
    
    Parametre:
    
    indexSnímky – index cieľovej snímky; platí to, čo pri všetkých metódach pracujúcich s indexmi snímok – ak je táto hodnota väčšia alebo rovná než je aktuálny počet snímok, tak bude prepočítaná tak, aby ukazovala na adekvátne vzdialenú snímku v rámci cyklickej animácie (čiže hodnota rovná počtu snímok bude presmerovaná na prvú snímku – s indexom nula, hodnota o jedno vyššia na druhú – s indexom dva a tak ďalej); záporné hodnoty budú prepočítané v opačnom smere (od konca animácie)
    
    Návratová hodnota:
    
    trvanie zobrazenia cieľovej snímky počas animácie v sekundách s presnosťou na tisíciny (pri jednotkovej rýchlosti prehrávania)
  - trvanieZobrazeniaSnímky
```
public double trvanieZobrazeniaSnímky()
```
    Zistí hodnotu trvania zobrazenia aktívnej snímky. (Prípadne aktuálnu naposledy použitú hodnotu trvania, ak animácia nemá žiadne snímky.)
    
    Návratová hodnota:
    
    trvanie zobrazenia aktívnej snímky počas animácie v sekundách s presnosťou na tisíciny (pri jednotkovej rýchlosti prehrávania)
  - trvanieZobrazeniaSnimky
```
public double trvanieZobrazeniaSnimky()
```
    Alias pre trvanieZobrazeniaSnímky.
  - trvanieZobrazeniaSnímky
```
public double trvanieZobrazeniaSnímky(int indexSnímky)
```
    Zistí hodnotu trvania zobrazenia zadanej snímky. (Prípadne aktuálnu naposledy použitú hodnotu trvania, ak animácia nemá žiadne snímky.)
    
    Parametre:
    
    indexSnímky – index cieľovej snímky; platí to, čo pri všetkých metódach pracujúcich s indexmi snímok – ak je táto hodnota väčšia alebo rovná než je aktuálny počet snímok, tak bude prepočítaná tak, aby ukazovala na adekvátne vzdialenú snímku v rámci cyklickej animácie (čiže hodnota rovná počtu snímok bude presmerovaná na prvú snímku – s indexom nula, hodnota o jedno vyššia na druhú – s indexom dva a tak ďalej); záporné hodnoty budú prepočítané v opačnom smere (od konca animácie)
    
    Návratová hodnota:
    
    trvanie zobrazenia cieľovej snímky počas animácie v sekundách s presnosťou na tisíciny (pri jednotkovej rýchlosti prehrávania)
  - trvanieZobrazeniaSnimky
```
public double trvanieZobrazeniaSnimky(int indexSnímky)
```
    Alias pre trvanieZobrazeniaSnímky.
  - trvanie
```
public void trvanie(double trvanie)
```
    Nastaví novú hodnotu trvania aktívnej snímky.
    
    Parametre:
    
    trvanie – nový čas zobrazenia aktívnej snímky v sekundách s presnosťou na tisíciny
  - trvanie
```
public void trvanie(int indexSnímky,
                    double trvanie)
```
    Nastaví novú hodnotu trvania zadanej snímky.
    
    Parametre:
    
    indexSnímky – index cieľovej snímky; platí to, čo pri všetkých metódach pracujúcich s indexmi snímok – ak je táto hodnota väčšia alebo rovná než je aktuálny počet snímok, tak bude prepočítaná tak, aby ukazovala na adekvátne vzdialenú snímku v rámci cyklickej animácie (čiže hodnota rovná počtu snímok bude presmerovaná na prvú snímku – s indexom nula, hodnota o jedno vyššia na druhú – s indexom dva a tak ďalej); záporné hodnoty budú prepočítané v opačnom smere (od konca animácie)
    
    trvanie – nový čas zobrazenia cieľovej snímky v sekundách s presnosťou na tisíciny
  - trvanieZobrazeniaSnímky
```
public void trvanieZobrazeniaSnímky(double trvanie)
```
    Nastaví novú hodnotu trvania aktívnej snímky.
    
    Parametre:
    
    trvanie – nový čas zobrazenia aktívnej snímky v sekundách s presnosťou na tisíciny
  - trvanieZobrazeniaSnimky
```
public void trvanieZobrazeniaSnimky(double trvanie)
```
    Alias pre trvanieZobrazeniaSnímky.
  - trvanieZobrazeniaSnímky
```
public void trvanieZobrazeniaSnímky(int indexSnímky,
                                    double trvanie)
```
    Nastaví novú hodnotu trvania zadanej snímky.
    
    Parametre:
    
    indexSnímky – index cieľovej snímky; platí to, čo pri všetkých metódach pracujúcich s indexmi snímok – ak je táto hodnota väčšia alebo rovná než je aktuálny počet snímok, tak bude prepočítaná tak, aby ukazovala na adekvátne vzdialenú snímku v rámci cyklickej animácie (čiže hodnota rovná počtu snímok bude presmerovaná na prvú snímku – s indexom nula, hodnota o jedno vyššia na druhú – s indexom dva a tak ďalej); záporné hodnoty budú prepočítané v opačnom smere (od konca animácie)
    
    trvanie – nový čas zobrazenia cieľovej snímky v sekundách s presnosťou na tisíciny
  - trvanieZobrazeniaSnimky
```
public void trvanieZobrazeniaSnimky(int indexSnímky,
                                    double trvanie)
```
    Alias pre trvanieZobrazeniaSnímky.
  - animujeSa
```
public boolean animujeSa()
```
    Zistí, či je práve spustená animácia obrázka.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
    
    Návratová hodnota:
    
    true ak je práve spustená animácia obrázka, false v opačnom prípade
  - opakovaniaAnimácie
```
public int opakovaniaAnimácie()
```
    Zistí, koľko opakovaní zostáva do ukončenia animácie. Hodnota -1 znamená, že animácia má byť prehrávaná donekonečna.
    
    Návratová hodnota:
    
    počet opakovaní zostávajúci do ukončenia animácie alebo -1 v prípade nekonečne sa opakujúcej animácie
  - opakovaniaAnimacie
```
public int opakovaniaAnimacie()
```
    Alias pre opakovaniaAnimácie.
  - početOpakovaní
```
public int početOpakovaní()
```
    Zistí, koľko opakovaní zostáva do ukončenia animácie. Hodnota -1 znamená, že animácia má byť prehrávaná donekonečna.
    
    Návratová hodnota:
    
    počet opakovaní zostávajúci do ukončenia animácie alebo -1 v prípade nekonečne sa opakujúcej animácie
  - pocetOpakovani
```
public int pocetOpakovani()
```
    Alias pre početOpakovaní.
  - opakovaniaAnimácie
```
public void opakovaniaAnimácie(int početOpakovaní)
```
    Ak má tento obrázok nenulový počet snímok animácie, tak táto metóda nastaví nový počet opakovaní animácie zostávajúci do ukončenia animácie a to bez ohľadu na to, či je animácia spustená alebo nie. Hodnota -1 znamená, že animácia má byť prehrávaná donekonečna. Ak je zadaná nula, tak prípadná spustená animácia bude zastavená.
    
    Upozornenie: Počítadlo opakovaní sa vzťahuje na momenty reštartovania animácie, to znamená, že hodnota počítadla je znížená po prejdení animácie z konca na začiatok alebo naopak, podľa smeru prehrávania animácie. To znamená, že ak nie je nastavená správna snímka (začiatočná alebo koncová podľa smeru prehrávania), tak sa môže animácia skončiť hneď po jej spustení (ak malo byť vykonané len jedno opakovanie) alebo sa nevykoná celá, podľa toho, ktorá snímka bola práve aktívna.
    
    Parametre:
    
    početOpakovaní – počet opakovaní animácie, po ktorom sa animácia ukončí; hodnota -1 je rezervovaná pre nekonečný počet opakovaní (v skutočnosti akákoľvek zadaná záporná hodnota nastaví počet opakovaní na hodnotu -1); hodnota 0 spôsobí zastavenie animácie (ak náhodou prebieha)
  - opakovaniaAnimacie
```
public void opakovaniaAnimacie(int početOpakovaní)
```
    Alias pre opakovaniaAnimácie.
  - početOpakovaní
```
public void početOpakovaní(int početOpakovaní)
```
    Ak má tento obrázok nenulový počet snímok animácie, tak táto metóda nastaví nový počet opakovaní animácie zostávajúci do ukončenia animácie a to bez ohľadu na to, či je animácia spustená alebo nie. Hodnota -1 znamená, že animácia má byť prehrávaná donekonečna. Ak je zadaná nula, tak prípadná spustená animácia bude zastavená.
    
    Upozornenie: Počítadlo opakovaní sa vzťahuje na momenty reštartovania animácie, to znamená, že hodnota počítadla je znížená po prejdení animácie z konca na začiatok alebo naopak, podľa smeru prehrávania animácie. To znamená, že ak nie je nastavená správna snímka (začiatočná alebo koncová podľa smeru prehrávania), tak sa môže animácia skončiť hneď po jej spustení (ak malo byť vykonané len jedno opakovanie) alebo sa nevykoná celá, podľa toho, ktorá snímka bola práve aktívna.
    
    Parametre:
    
    početOpakovaní – počet opakovaní animácie, po ktorom sa animácia ukončí; hodnota -1 je rezervovaná pre nekonečný počet opakovaní (v skutočnosti akákoľvek zadaná záporná hodnota nastaví počet opakovaní na hodnotu -1); hodnota 0 spôsobí zastavenie animácie (ak náhodou prebieha)
  - pocetOpakovani
```
public void pocetOpakovani(int početOpakovaní)
```
    Alias pre početOpakovaní.
  - spusti
```
public void spusti()
```
    Spustí animáciu s nekonečným počtom opakovaní v naposledy použitom smere prehrávania. Ak bola animácia už spustená, tak iba nastaví nekonečný počet opakovaní.
  - spustiAnimáciu
```
public void spustiAnimáciu()
```
    Spustí animáciu s nekonečným počtom opakovaní v naposledy použitom smere prehrávania. Ak bola animácia už spustená, tak iba nastaví nekonečný počet opakovaní.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
  - spustiAnimaciu
```
public void spustiAnimaciu()
```
    Alias pre spustiAnimáciu.
  - spusti
```
public void spusti(int početOpakovaní)
```
    Spustí animáciu so zadaným počtom opakovaní v naposledy použitom smere prehrávania. Ak bola animácia už spustená, tak iba nastaví zadaný počet opakovaní. Ak je zadaný počet opakovaní rovný nule, tak je animácia zastavená.
    
    Upozornenie: Počítadlo opakovaní sa vzťahuje na momenty reštartovania animácie, to znamená, že hodnota počítadla je znížená po prejdení animácie z konca na začiatok alebo naopak, podľa smeru prehrávania animácie. To znamená, že ak nie je nastavená správna snímka (začiatočná alebo koncová podľa smeru prehrávania), tak sa môže animácia skončiť hneď po jej spustení (ak malo byť vykonané len jedno opakovanie) alebo sa nevykoná celá, podľa toho, ktorá snímka bola práve aktívna.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
    
    Parametre:
    
    početOpakovaní – počet opakovaní animácie, po ktorom sa animácia ukončí; hodnota -1 je rezervovaná pre nekonečný počet opakovaní (v skutočnosti akákoľvek zadaná záporná hodnota nastaví počet opakovaní na hodnotu -1); hodnota 0 spôsobí zastavenie animácie (ak náhodou prebieha)
  - spustiAnimáciu
```
public void spustiAnimáciu(int početOpakovaní)
```
    Spustí animáciu so zadaným počtom opakovaní v naposledy použitom smere prehrávania. Ak bola animácia už spustená, tak iba nastaví zadaný počet opakovaní. Ak je zadaný počet opakovaní rovný nule, tak je animácia zastavená.
    
    Upozornenie: Počítadlo opakovaní sa vzťahuje na momenty reštartovania animácie, to znamená, že hodnota počítadla je znížená po prejdení animácie z konca na začiatok alebo naopak, podľa smeru prehrávania animácie. To znamená, že ak nie je nastavená správna snímka (začiatočná alebo koncová podľa smeru prehrávania), tak sa môže animácia skončiť hneď po jej spustení (ak malo byť vykonané len jedno opakovanie) alebo sa nevykoná celá, podľa toho, ktorá snímka bola práve aktívna.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
    
    Parametre:
    
    početOpakovaní – počet opakovaní animácie, po ktorom sa animácia ukončí; hodnota -1 je rezervovaná pre nekonečný počet opakovaní (v skutočnosti akákoľvek zadaná záporná hodnota nastaví počet opakovaní na hodnotu -1); hodnota 0 spôsobí zastavenie animácie (ak náhodou prebieha)
  - spustiAnimaciu
```
public void spustiAnimaciu(int početOpakovaní)
```
    Alias pre spustiAnimáciu.
  - spustiDopredu
```
public void spustiDopredu()
```
    Spustí animáciu dopredu s nekonečným počtom opakovaní. Ak bola animácia už spustená, tak iba upraví smer prehrávania a nastaví nekonečný počet opakovaní.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
  - spustiAnimáciuDopredu
```
public void spustiAnimáciuDopredu()
```
    Spustí animáciu dopredu s nekonečným počtom opakovaní. Ak bola animácia už spustená, tak iba upraví smer prehrávania a nastaví nekonečný počet opakovaní.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
  - spustiAnimaciuDopredu
```
public void spustiAnimaciuDopredu()
```
    Alias pre spustiAnimáciuDopredu.
  - spustiDopredu
```
public void spustiDopredu(int početOpakovaní)
```
    Spustí animáciu dopredu so zadaným počtom opakovaní. Ak bola animácia už spustená, tak iba upraví smer prehrávania a nastaví zadaný počet opakovaní. Ak je zadaný počet opakovaní rovný nule, tak je animácia zastavená.
    
    Upozornenie: Počítadlo opakovaní sa vzťahuje na momenty reštartovania animácie, to znamená, že hodnota počítadla je znížená po prejdení animácie z konca na začiatok alebo naopak, podľa smeru prehrávania animácie. To znamená, že ak nie je nastavená správna snímka (začiatočná alebo koncová podľa smeru prehrávania), tak sa môže animácia skončiť hneď po jej spustení (ak malo byť vykonané len jedno opakovanie) alebo sa nevykoná celá, podľa toho, ktorá snímka bola práve aktívna.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
    
    Parametre:
    
    početOpakovaní – počet opakovaní animácie, po ktorom sa animácia ukončí; hodnota -1 je rezervovaná pre nekonečný počet opakovaní (v skutočnosti akákoľvek zadaná záporná hodnota nastaví počet opakovaní na hodnotu -1); hodnota 0 spôsobí zastavenie animácie (ak náhodou prebieha)
  - spustiAnimáciuDopredu
```
public void spustiAnimáciuDopredu(int početOpakovaní)
```
    Spustí animáciu dopredu so zadaným počtom opakovaní. Ak bola animácia už spustená, tak iba upraví smer prehrávania a nastaví zadaný počet opakovaní. Ak je zadaný počet opakovaní rovný nule, tak je animácia zastavená.
    
    Upozornenie: Počítadlo opakovaní sa vzťahuje na momenty reštartovania animácie, to znamená, že hodnota počítadla je znížená po prejdení animácie z konca na začiatok alebo naopak, podľa smeru prehrávania animácie. To znamená, že ak nie je nastavená správna snímka (začiatočná alebo koncová podľa smeru prehrávania), tak sa môže animácia skončiť hneď po jej spustení (ak malo byť vykonané len jedno opakovanie) alebo sa nevykoná celá, podľa toho, ktorá snímka bola práve aktívna.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
    
    Parametre:
    
    početOpakovaní – počet opakovaní animácie, po ktorom sa animácia ukončí; hodnota -1 je rezervovaná pre nekonečný počet opakovaní (v skutočnosti akákoľvek zadaná záporná hodnota nastaví počet opakovaní na hodnotu -1); hodnota 0 spôsobí zastavenie animácie (ak náhodou prebieha)
  - spustiAnimaciuDopredu
```
public void spustiAnimaciuDopredu(int početOpakovaní)
```
    Alias pre spustiAnimáciuDopredu.
  - spustiPospiatku
```
public void spustiPospiatku()
```
    Spustí animáciu pospiatku s nekonečným počtom opakovaní. Ak bola animácia už spustená, tak iba upraví smer prehrávania (pospiatku) a nastaví nekonečný počet opakovaní.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
  - spustiAnimáciuPospiatku
```
public void spustiAnimáciuPospiatku()
```
    Spustí animáciu pospiatku s nekonečným počtom opakovaní. Ak bola animácia už spustená, tak iba upraví smer prehrávania (pospiatku) a nastaví nekonečný počet opakovaní.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
  - spustiAnimaciuPospiatku
```
public void spustiAnimaciuPospiatku()
```
    Alias pre spustiAnimáciuPospiatku.
  - spustiPospiatku
```
public void spustiPospiatku(int početOpakovaní)
```
    Spustí animáciu pospiatku so zadaným počtom opakovaní. Ak bola animácia už spustená, tak iba upraví smer prehrávania (pospiatku) a nastaví zadaný počet opakovaní. Ak je zadaný počet opakovaní rovný nule, tak je animácia zastavená.
    
    Upozornenie: Počítadlo opakovaní sa vzťahuje na momenty reštartovania animácie, to znamená, že hodnota počítadla je znížená po prejdení animácie z konca na začiatok alebo naopak, podľa smeru prehrávania animácie. To znamená, že ak nie je nastavená správna snímka (začiatočná alebo koncová podľa smeru prehrávania), tak sa môže animácia skončiť hneď po jej spustení (ak malo byť vykonané len jedno opakovanie) alebo sa nevykoná celá, podľa toho, ktorá snímka bola práve aktívna.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
    
    Parametre:
    
    početOpakovaní – počet opakovaní animácie, po ktorom sa animácia ukončí; hodnota -1 je rezervovaná pre nekonečný počet opakovaní (v skutočnosti akákoľvek zadaná záporná hodnota nastaví počet opakovaní na hodnotu -1); hodnota 0 spôsobí zastavenie animácie (ak náhodou prebieha)
  - spustiAnimáciuPospiatku
```
public void spustiAnimáciuPospiatku(int početOpakovaní)
```
    Spustí animáciu pospiatku so zadaným počtom opakovaní. Ak bola animácia už spustená, tak iba upraví smer prehrávania (pospiatku) a nastaví zadaný počet opakovaní. Ak je zadaný počet opakovaní rovný nule, tak je animácia zastavená.
    
    Upozornenie: Počítadlo opakovaní sa vzťahuje na momenty reštartovania animácie, to znamená, že hodnota počítadla je znížená po prejdení animácie z konca na začiatok alebo naopak, podľa smeru prehrávania animácie. To znamená, že ak nie je nastavená správna snímka (začiatočná alebo koncová podľa smeru prehrávania), tak sa môže animácia skončiť hneď po jej spustení (ak malo byť vykonané len jedno opakovanie) alebo sa nevykoná celá, podľa toho, ktorá snímka bola práve aktívna.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
    
    Parametre:
    
    početOpakovaní – počet opakovaní animácie, po ktorom sa animácia ukončí; hodnota -1 je rezervovaná pre nekonečný počet opakovaní (v skutočnosti akákoľvek zadaná záporná hodnota nastaví počet opakovaní na hodnotu -1); hodnota 0 spôsobí zastavenie animácie (ak náhodou prebieha)
  - spustiAnimaciuPospiatku
```
public void spustiAnimaciuPospiatku(int početOpakovaní)
```
    Alias pre spustiAnimáciuPospiatku.
  - zastav
```
public void zastav()
```
    Zastaví prehrávanie animácie tohto obrázka.
    
    Poznámka: Pozri aj informácie o snímkach uvedené v opise metódy početSnímok (tieto informácie súvisia aj s vykonávaním animácie).
    
    Táto metóda je vo viacerých prípadoch spúšťaná automaticky. Napríklad po dokončení všetkých opakovaní animácie, nastavení počtu opakovaní alebo rýchlosti prehrávania animácie na nulu, vymazaní všetkých snímok animácie a podobne. Ak animácia prebiehala, tak vykonanie tejto metódy spustí prekryté reakcie robota zastavenieAnimácie a/alebo rovnomennú reakciu aktívnej obsluhy udalostí – zastavenieAnimácie.
  - zastavAnimáciu
```
public void zastavAnimáciu()
```
    Alias pre zastav.
  - zastavAnimaciu
```
public void zastavAnimaciu()
```
    Alias pre zastav.


Ukážky možného vzhľadu prečítanej animáce, ak bola sekvencia vygenerovaná príkladom z opisu metódy `ulož(súbor, prepísať)` (plátno ukážok je úmyselne zmenšené).


a) predvolená paleta	b) použitie metódy priemerovania	c) použitie metódy vyváženia zložiek
Porovnanie rôznych metód prevodu do odtieňov šedej.

	-240,0	-160,0	-80,0	0,0	80,0	160,0	240,0
-240,0
-160,0
-80,0
0,0
80,0
160,0
240,0
	rôzne úrovne jasu


Ukážky možného vzhľadu vytvorenej animáce – výsledok každého generovania je unikátny (plátno ukážok je úmyselne zmenšené).

Trieda Obrázok

Prehľad atribútov

Atribúty zdedené z triedy java.awt.image.BufferedImage

Atribúty zdedené z triedy java.awt.Image

Atribúty zdedené z rozhrania Priehľadnosť

Atribúty zdedené z rozhrania java.awt.Transparency

Prehľad konštruktorov

Prehľad metód

Metódy zdedené z triedy java.awt.image.BufferedImage

Metódy zdedené z triedy java.awt.Image

Metódy zdedené z triedy java.lang.Object

Podrobnosti atribútov

šírka

sirka

výška

vyska

grafika

Podrobnosti konštruktorov

Obrázok

Obrázok

Obrázok

Podrobnosti metód

priečinokObrázkov

priecinokObrazkov

priečinokObrázkov

priecinokObrazkov

čítaj

citaj

prečítaj

precitaj

čítaj

citaj

prečítaj

precitaj

šírka

sirka

výška

vyska

šírka

sirka

výška

vyska

rozmery

rozmery

máŠírku

maSirku

máVýšku

maVysku

máRozmer

maRozmer

máRozmer

maRozmer

zmeňVeľkosť

zmenVelkost

zmeňVeľkosť

zmenVelkost

grafika

kresliVšade

kresliVsade

kresliDo

nekresliDo

najmenšieX

najmensieX

minimálneX

minimalneX

najmenšieY

najmensieY

minimálneY

minimalneY

najväčšieX

najvacsieX

maximálneX

maximalneX

najväčšieY

najvacsieY

maximálneY

maximalneY

vymaž

vymaz

prepíšBod