Matematické výrazy a skriptovanie

    Od verzie 0.8.7. QtiPlot podporuje rôzne možnosti vyhodnocovania matematických výrazov a vykonávania skriptov.

    Definované sú konštanty _e=e=E a _pi=pi=PI=Pi a tiež nasledujúce operátory a funkcie.

    Tento modul je väzbou s programovacím jazykom Python. Základy Pythonu súvisiace s programom QtiPlot sú popísané v tejto časti, pre viac informácií o samotnom jazyku je potrebné preštudovať jeho dokumentáciu.

    Tento súbor umožňuje prispôsobiť prostredie Pythonu, importovať moduly a definovať funkcie a triedy, ktoré budú potom dostupné pre všetky vaše projekty. Inicializačný súbor, ktorý je súčasťou QtiPlot, improtuje štandardné matematické funkcie Pythonu a tiež špeciálne funkcie zo SciPy (ak je dostupný). Taktiež vytvára niektoré skratky, ktoré sú vhodné pre písanie skriptov, napríklad table("table1") pre qti.app.table("table1").
    Pri aktivovaní podpory Pythonu QtiPlot prehľadáva súbory a vykoná príkazy prvého súboru, ktorý nájde:

    Súbory s príponou .pyc sú kompilované verzie zdrojových súborov .py a preto je určitý rozdiel v ich rýchlosti načítania. Kompilované verzie sa použijú v prípade, že zdrojový súbor je starší alebo neexistuje. Inak sa QtiPlot pokúsi kompilovať zdrojový súbor (ak máte pre výstupný súbor povolenie zapisovať).

    Matematické výrazy sa používajú očakávaným spôsobom. Je tu však jeden problém, pri prepínaní z muParser (ktorý bol v starších verziách QtiPlot jediným skriptovacím jazykom): a^b neznamená a umocnené na b, ale bitové vylučujúce alebo a a b; operátor v Pythone pre mocninu je **. Preto:

2^3 # read: 10 xor 11 = 01
#> 1
2**3
#> 8

    Pri práci s Pythonom sú veľmi dôležité odseky. Používajú sa na zoskupovanie príkazov (väčšina iných jazykov na to používa buď okrúhle zátvorky alebo kľúčové slová ako do...end). Napríklad:

x=23
for i in (1,4,5):
    x=i**2
    print(x)

spraví to, čo očakávate: vypíše čísla 1, 16 a 25; každé na jeden riadok. Vymazanie čo i len jednej medzery spôsobí zmenu programu:

x=23
for i in (1,4,5):
    x=i**2
print(x)

    V tomto prípade sa vypíše iba jediné číslo, no nie 23, ale 25.
    Ďalšou dôležitou záležitosťou sú premenné. Python nemá žiadne lokálne premenné určené len pre blok.
    Existujú dva základné typy premenných: lokálne a globálne. Ak nie je špecifikované inak, premenné sú lokálne a vzťahujú sa na kontext, pre ktorý boli definované. A tak napríklad premenná x môže mať tri rôzne hodnoty v dvoch rôznych oknách poznámky a vo vzorci pre stĺpec. Na druhej strane globálne premenné sú prístupné v rámci celého projektu. Premenná x je považovaná za globálnu premennú definovaním stavu global x. To je potrebné spraviť ešte pred pridelením hodnoty pre x, no musí sa tak spraviť iba raz v rámci celého projektu (je potrebné "importovať" premennú ešte pred tým ako bude použitá). Menšia výnimka z tohto pravidla ale platí pri definovaní vlastných funkcií.

    Základná syntax na definovanie funkcie (pre použitie v jednej konkrétnej poznámke, napríklad) je

def answer():
    return 42

    Ak chcete, aby bola vaša funkcia dostupná aj pre zvyšok projektu, musíte ju definovať ako globálnu ešte pred jej samotným definovaním:

global answer
def answer():
    return 42

    Taktiež je možné pridať vlastnú funkciu do zoznamu funkcií QtiPlot. Nasledujúci skript je príkladom pre dialógové okno set column values:
global answer

def answer():
    "Return the answer to the ultimate question about life, the universe and everything."
    return 42
qti.mathFunctions["answer"] = answer

    Ak chcete funkciu zo zoznamu odstrániť, použite príkaz:

del qti.mathFunctions["answer"]

    Nezabúdajte na lokálny rozmer funkcií. To znamená, že ak napríklad zadáte definíciu funkcie v poznámke, prístup (čítanie ani zapisovanie) k lokálnym premenným poznámky vo vnútri funkcie nebude možný. Prístup ku globálnym premenným funguje ako obvykle.
    Použitie if-then-else je nasledovné:

if x>23:
    print(x)
else:
    print("The value is too small.")

    Taktiež je možné používať slučky:

for i in range(1, 11):
    print(i)

    Vypíšu sa čísla od 1 do 10, vrátane (horná hranica nepatrí do rozsahu, zatiaľ čo dolná áno).

    Python používa niektoré základné matematické funkcie, ktoré sa importujú automaticky (ak používate inicializačný súbor dodávaný s QtiPlot). Spolu s nimi sú definované aj konštanty e (Eulerovo číslo) a pi.

    Budeme predpokladať, že používate inicializačný súbor dodávaný s QtiPlot. Prístup k objektom projektu je priamy:

t = table("Table1")
m = matrix("Matrix1")
g = graph("Graph1")
n = note("Notes1")

ako aj vytváranie nových objektov:

# vytvorenie novej tabuľky s názvom "tony" s 5 riadkami a 2 stĺpcami:
t = newTable("tony", 5, 2)
# použitie prednastavených hodnôt
t = newTable()
# vytvorenie prázdnej novej matice s názvom "gina" so 42 riadkami a 23 stĺpcami:
m = newMatrix("gina", 42, 23)
# použitie prednastavených hodnôt
m = newMatrix()
# vytvorenie prázdneho okna grafu
g = newGraph()
# vytvorenie okna grafu s názvom "test" s dvoma vrstvami rozdelenými na mriežku, ktorá má 2 riadky x 1 stĺpec
g = newGraph("test", 2, 2, 1)
# vytvorenie prázdneho okna poznámky s názvom "momo"
n = note("momo")
# použitie prednastavených hodnôt
n = note()

    Každá časť kódu sa vykonáva v súvislosti s objektom, ku ktorému sa cez samotnú premennú pristupuje. Napríklad zápis self.cell("t",i) pre stĺpec je totožný s konvenčnou funkciou col("t"). Keď raz zadefinujete prepojenie s oknom MDI, môžete prispôsobovať jeho vlastnosti akými sú názov, popis okna, geometria atď. Ako príklad je uvedený spôsob ako premenovať okno, zmeniť jeho menovku a spôsob, akými sa zobrazujú v titulku okna:

t = table("Table1")
setWindowName(t, "toto")
t.setWindowLabel("tutu")
t.setCaptionPolicy(MDIWindow.Both)

    Tento titulok okna môže mať nasledovné hodnoty:

    Pre rýchlu editáciu je možné vytvoriť súbory so šablónami z existujúcich tabuliek, matíc alebo grafov. Tieto šablóny môžu byť neskôr použité na jednoduché vytvorenie prispôsobených okien:

saveAsTemplate(graph("Graph1"), "my_plot.qpt")
g = openTemplate("my_plot.qpt")

    Taktiež je možné jednoducho duplikovať okno MDI:

g1 = clone(graph("Graph1"))

    Uchovávanie údajov tabuliek/matíc a grafov v priečinkoch môže byť veľmi vhodné a užitočné napríklad v prípade, že analyzujete množstvo údajových súborov v tom istom projekte. Do aktívneho priečinku budú vždy pridané nové objekty. Dostanete sa k nim cez:

f = activeFolder()

    Funkcie tabuľky, matice, grafu a poznámky začnú prehľadávať aktívny priečinok a ak tento spôsob zlyhá, bude sa pokračovať v hlbšom rekurzívnom prehľadávaní koreňového priečinku projektu daného ako:

f = rootFolder()

    Na prístup k podpriečinkom a oknám sa spravidla používajú nasledujúce funkcie:

f2 = f.folders()[number]
f2 = f.folder(name, caseSensitive=True, partialMatch=False)
t = f.table(name, recursive=False)
m = f.matrix(name, recursive=False)
g = f.graph(name, recursive=False)
n = f.note(name, recursive=False)

    Ak nastavíte pre rekurzívny argument hodnotu True, vykonané bude rekurzívne prehľadávanie všetkých podpriečinkov a vrátená bude prvá zhoda.
    Nové priečinky sa vytvárajú príkazom:

newFolder = addFolder("New Folder", parentFolder = 0)

    Ak zdrojový priečinok parentFolder nie je špecifikovaný, nový priečinok bude pridaný ako podpriečinok do koreňového priečinku projektu. Keď Pythonovým skriptom vytvoríte nový priečinok, nestane sa automaticky aktívnym priečinkom projektu. Je potrebné nastaviť ho použitím príkazu:

changeFolder(newFolder, bool force=False)

    Priečinky je možné zmazať použitím:

deleteFolder(folder)

    Je možné aj uložiť priečinok ako súbor projektu a samozrejme je možné uložiť aj celý projekt:

saveFolder(folder, "new_file.qti", compress=False)
saveProjectAs("new_file_2.qti", compress=False)

    Ak je komprimácia nastavená na True, projektový súbor bude uložený vo formáte .gz s použitím zlib.
    Taktiež je možné do nového priečinku načítať projektový súbor QtiPlot alebo Origin. Nový priečinok bude mať meno projektového súboru a bude pridaný ako podpriečinok do parentFolder alebo do aktuálneho priečinka, ak zdrojový priečinok nebol špecifikovaný.

newFolder = appendProject("projectName", parentFolder = 0)

    Ak nechcete, aby sa zobrazoval dotaz na potvrdenie operácie pri premenovaní tabuľky/matice alebo pri vymazaní priečinku prostredníctvom skriptu v Pythone, musíte zmeniť nastavenia týkajúce sa varovných správ v dialógovom okne Preferences (záložka Confirmations).

    Budeme predpokladať, že pre niektorú tabuľku bola priradená premenná t. Prístup k numerickým hodnotám bunky je možný cez:

t.cell(col, row)
# a
t.setCell(col, row, value)

    Kedykoľvek budete potrebovať špecifikovať stĺpec, môžete použiť buď názov stĺpca (ako reťazec) alebo poradové číslo stĺpca (číslovať sa začína od 1). Čísla riadkov taktiež začínajú od 1, čiže presne tak, ako sú zobrazované. Ak chcete pracovať s doplnkovým textom alebo textovým vyjadrením numerických hodnôt, môžete použiť:

t.text(col, row)
# a
t.setText(col, row, string)

    Počet riadkov a stĺpcov sa zisťuje cez:

t.numRows()
t.numCols()
t.setNumRows(number)
t.setNumCols(number)

    Rozsah riadkov je možné vymazať použitím:

t.deleteRows(startRowNumber, endRowNumber)

    Názvy stĺpcov môžu byť načítané a zapísané príkazmi:

t.colName(number)
t.setColName(col, newName, enumerateRight=False)

    Ak je hodnota enumerateRight nastavená na True, stĺpce tabuľky začínajúce od indexu col budú mať názvy modifikované kombináciou newName a numerickým vzostupným indexom. Ak tento parameter nebol špecifikovaný, prednastavená je hodnota False.
    Zmeniť úlohu stĺpca v tabuľke (X, Y, chybové hodnoty atď.) je možné použitím:

t.setColumnRole(col, role)

kde role špecifikuje nastavenie stĺpca:

    Je možné normalizovať jeden stĺpec alebo všetky stĺpce tabuľky:

t.normalize(col)
t.normalize()

    Usporiadanie jedného alebo všetkých stĺpcov:

t.sortColumn(col, order = 0);
t.sort(type = 0, order = 0, leadingColumnName)

    Importovanie hodnôt zo súboru file s použitím sep ako oddeľovacieho znaku, ignorovanie riadkov ignoreLines v hlavičke súboru a všetkých riadkov začínajúcich reťazcom definovaným v comment:

t.importASCII(file, sep="\t",ignoreLines=0,renameCols=False,stripSpaces=True,simplifySpace=False, importComments=False,comment="#",readOnly=False,importAs=Table.Overwrite, endLine=0,maxRows=-1)

    Ako je možné vidieť pri možnostiach importovania, máte možnosť nastaviť, že nové stĺpce budú iba na čítanie. To ochráni importované údaje pred tým, aby boli modifikované. Odstrániť túto ochranu je možné kedykoľvek použitím:

t.setReadOnlyColumn(col, False)

    ImportAs môže mať nasledovné hodnoty:

    EndLine špecifikuje znak konca riadku použitého v ASCII súbore. Možné hodnoty sú: 0 pre posun riadka (LF - line feed), čo je aj prednastavená hodnota, 1 pre návrat+posun riadka (CRLF - carriage return + line feed) a 2 pre samotný návrat (zvyčajne sa používa v počítačoch Mac).
    Posledný parameter maxRows umožňuje zadať maximálny počet importovaných riadkov.
    Ďalšou možnosťou je exportovať hodnoty tabuľky do ASCII súboru použitím sep ako oddeľovacieho znaku. Možnosť ColumnLabels umožňuje exportovať alebo ignorovať menovky stĺpcov, možnosť ColumnComments má rovnaký význam pre komentáre zobrazené v hlavičke tabuľky a možnosť SelectionOnly umožňuje exportovať iba vybrané bunky tabuľky.

t.exportASCII(file,sep="\t",ignore=0,ColumnLabels=False,ColumnComments=False,SelectionOnly=False)

    Ďalšie nastavenia, ktoré je možné modifikovať, sú text zobrazený ako komentár v hlavičke stĺpca alebo výraz použitý na výpočet hodnôt stĺpca. Je potrebné si uvedomiť, že zmena príkazu neznamená automatickú zmenu hodnôt stĺpca!

t.setComment(col, newComment)
t.setCommand(col, newExpression)

    Po zmene niektorých hodnôt tabuľky zo skriptu budete chcieť pravdepodobne aktualizovať aj súvisiace grafy:

t.notifyChanges()

    Taktiež je možné zmeniť šírku stĺpca (v pixeloch) alebo skryť/zobraziť stĺpce tabuľky:

t.setColumnWidth(col, width)
t.hideColumn(col, True)

    Jednoduchý príklad, ako nastaviť niektoré hodnoty stĺpca bez použitia dialógového okna, môže vyzerať takto:

t = table("table1")
for i in range(1, t.numRows()+1):
    t.setCell(1, i, i**2)
t.notifyChanges()

    Matice ako objekty majú dva spôsoby zobrazovania: buď ako obrázky alebo ako tabuľky s údajmi. Za predpokladu, že premennej m bola priradená nejaká matica, je možné zmeniť jej spôsob zobrazenia použitím nasledujúcej funkcie:

m.setViewType(Matrix.TableView)
m.setViewType(Matrix.ImageView)

    Ak sa matica zobrazuje ako obrázok, je tu možnosť zobraziť ju buď v stupňoch šedej alebo použitím preddefinovanej farebnej mapy:

m.setGrayScale()
m.setRainbowColorMap()

    Prístup k hodnotám buniek je podobný ako to bolo u tabuliek, lenže matica nepoužíva logické stĺpce, takže argumenty riadku sa zadávajú pred argumentmi stĺpcov a samozrejme nie je možné použiť názov stĺpca.

m.cell(row, col)
m.setCell(row, col, value)
m.text(row, col)
m.setText(row, col, string)

    Alternatívnym riešením je priradiť hodnoty matici, potrebné je definovať výraz a vypočítať z tohto výrazu hodnoty ako v nasledujúcom príklade:

m.setFormula("x*y*sin(x*y)")
m.calculate()

    Taktiež je možné špecifikovať rozsah stĺpcov/riadkov vo funkcii calculate() a to nasledovne:

m.calculate(startRow, endRow, startColumn, endColumn)

    Pred nastavením hodnôt v matici je možné definovať aj numerickú presnosť, čiže počet číslic použitých pri výpočtoch:

m.setNumericPrecision(prec)

    Podobne ako pri tabuľkách je možné získať počet riadkov/stĺpcov v matici:

rows = m.numRows()
columns = m.numCols()

    Objekty matice umožňujú definovať systém súradníc x/y, ktoré budú použité na vykreslenie farebných/obrysových máp alebo 3D máp. Narábať s týmito súradnicami je možné použitím nasledujúcich funkcií:

xs = m.xStart()
xe = m.xEnd()
ys = m.yStart()
ye = m.yEnd()
m.setCoordinates(xs + 2.5, xe, ys - 1, ye + 1)

    Horizontálne a vertikálne hlavičky matice môžu byť zobrazené buď ako súradnice x/y alebo ako indexy stĺpcov/riadkov:

m.setHeaderViewType(Matrix.ColumnRow)
m.setHeaderViewType(Matrix.XY)

    Preddeklarovaných je niekoľko transformácií, ktoré je možné použiť na objekt matice. Maticu je možné transponovať alebo invertovať a počítať jej determinant, samozrejme za predpokladu, že podmienky ako napríklad rozmery matice požadované pre danú operáciu, boli splnené:

m.transpose()
m.invert()
d = m.determinant()

    Je možné vykonať aj ďalšie operácie, ktoré sú užitočné pri práci s obrázkami, napríklad rotácia o 90 stupňov a zrkadlenie. Prednastavená je rotácia v smere hodinových ručičiek. Pre rotáciu proti smeru hodinových ručičiek musíte nastaviť parameter clockwise na False.

m.flipVertically()
m.flipHorizontally()
m.rotate90(clockwise = True)

    Myslite na to, že niekedy je po zmene nastavení matice potrebné použiť nasledujúcu funkciu, aby ste aktualizovali zobrazenie:

m.resetView()

    Ak potrebujete získať údaje z tabuľky, ktoré použijete do matice (alebo naopak), môžete ušetriť čas potrebný na kopírovanie a vkladanie a urýchliť celý proces jednoduchým konvertovaním tabuľky na maticu:

m = tableToMatrix(table("Table1"))
t = matrixToTable(m)

    Taktiež je dobré vedieť, že do matíc je možné jednoducho importovať aj obrázkové súbory, ktoré môžu byť následne použité pri tvorbe grafov (pre viac informácií pozri nasledujúcu časť o 2D grafoch):

m1 = importImage("C:/poze/adi/PIC00074.jpg")
m2 = newMatrix()
m2.importImage("C:/poze/adi/PIC00075.jpg")

    Algoritmus používaný na importovanie obrázkov vracia hodnotu šedej v rozmedzí 0 až 255 pre trojicu (r, g, b) odpovedajúcu každému pixelu. Hodnota šedej sa počíta použitím výrazu: (r * 11 + g * 16 + b * 5)/32.
    Pre analytické operácie týkajúce sa prispôsobovania obrázkov je možné vytvoriť kópiu matice obrázku ako objekt Qimage cez:

image = m.image()

    Matice je možné exportovať do všetkých rastrových obrázkových formátov podporovaných Qt alebo do niektorého z nasledujúcich vektorových obrázkových formátov EPS, PS, PDF alebo SVG použitím:

m.export(fileName)

    Ide o skrátenú funkciu, ktorá na vygenerovanie obrázku používa niektoré predvolené parametre. Ak chcete mať zadať viac parametrov exportovania, musíte použiť jednu z nasledujúcich funkcií:

m1.exportRasterImage(fileName, quality = 100)
m2.exportVector(fileName,resolution,color = true,keepAspect = true,pageSize = QPrinter::Custom)

    Taktiež môžete importovať ASCII súbor file, nastaviť sep ako oddeľovací znak, cez ignore nastaviť vynechanie riadkov hlavičky a vynechanie všetkých riadkov začínajúcich reťazcom definovaným v comment:

m.importASCII(file, sep="\t", ignore=0, stripSpaces=True, simplifySpace=False, comment="#",importAs=Matrix.Overwrite, locale=QLocale(), endLine=0, maxRows=-1)

    ImportAs môže mať nasledovné hodnoty:

    Parameter locale môže byť použitý na špecifikovanie oddeľovača desatinných miest použitého v ASCII súbore.
    EndLine špecifikuje znak konca riadku použitého v ASCII súbore. Možné hodnoty sú: 0 pre posun riadka (LF - line feed), čo je aj prednastavená hodnota, 1 pre návrat+posun riadka (CRLF - carriage return + line feed) a 2 pre samotný návrat (zvyčajne sa používa v počítačoch Mac).
    Posledný parameter maxRows umožňuje špecifikovať maximálny počet riadkov, ktoré budú importované.
    Taktiež je možné exportovať hodnoty matice do ASCII súboru, pričom sep špecifikuje oddeľovač znakov. Možnosť SelectionOnly umožňuje exportovať iba vybrané bunky matice.

m.exportASCII(file, sep="\t", SelectionOnly=False)

    Ako bolo možné vidieť v predošlej časti, z matíc je možné vytvoriť 2D grafy. A tu je spôsob ako to urobiť:

m = importImage("C:/poze/adi/PIC00074.jpg")
g1 = plot(m, Layer.ColorMap)
g2 = plot(m, Layer.Contour)
g3 = plot(m, Layer.GrayScale)

    Ak chcete vytvoriť nové okno grafu z údajov v tabuľke Table1, môžete použiť príkaz na tvorbu grafu:

t = table("Table1")
g = plot(t, column, type)

    Type špecifikuje požadovaný typ grafu a môže ním byť jedno z nasledujúcich čísiel alebo odpovedajúce vyhradené slovo:

    Zadaním argumentov je možné vykresliť aj viac ako jeden stĺpec naraz:

g1 = plot(table("Table1"), (2,4,7), 2)
g2 = plot(table("Table1"), ("Table1_2","Table1_3"), Layer.LineSymbols)

    Taktiež je možné vytvoriť aj vektorový graf a to vybraním štyroch stĺpcov a zadaním typu grafu Layer.VectXYXY (11) alebo Layer.VectXYAM (14), v závislosti od toho, ako je definovaný koncový bod vektorov: či sa používajú súradnice (X, Y) alebo polárne súradnice (uhol, vzdialenosť).

g = plot(table("Table1"), (2,3,4,5), Layer.VectXYXY)

    Ak chcete pridať krivku do existujúceho okna grafu, musíte zvoliť cieľovú vrstvu. Zvyčajne sa používa príkaz:

l = g.activeLayer()

    No je možné aj zvoliť vrstvu prostredníctvom jej čísla:

l = g.layer(num)


    7.2.9.1. Práca s krivkami
    Na vrstvu môžete pridávať krivky alebo ich odstraňovať:

l.insertCurve(table, Xcolumn, Ycolumn, type=Layer.Scatter)
l.addCurve(table, column, type=Layer.Line, lineWidth = 1, symbolSize = 3, startRow = 0, endRow = -1)
l.addCurves(table, (2,4), type=Layer.Line, lineWidth = 1, symbolSize = 3, startRow = 0, endRow = -1)
l.removeCurve(curveName)
l.removeCurve(curveNumber)
l.deleteFitCurves()

    Na vrstvu grafu je možné pridávať aj krivky zadávané analytickou funkciou:

l.addFunction("x*sin(x)", 0, 3*pi, points = 100);
l.addParametricFunction("cos(m)", "sin(m)", 0, 2*pi, points = 100, variableName = "m")
l.addPolarFunction("t", "t", 0, 2*pi, points = 100, variableName = "t")

    V prípade, že potrebujete zistiť počet kriviek na vrstve, môžete tak urobiť príkazom:

l.numCurves()


    7.2.9.2. Menovka grafu

l.setTitle("My beautiful plot")
l.setTitleFont(QtGui.QFont("Arial", 12))
l.setTitleColor(QtGui.QColor("red"))
l.setTitleAlignment(QtCore.Qt.AlignLeft)

    Parameter zarovnania môže byť akoukoľvek kombináciou zarovnania Qt (pre viac informácií pozri dokumentáciu ku PyQt).
    Ak chcete menovku grafu odstrániť, použite:

l.removeTitle()


    7.2.9.3. Prispôsobovanie osí
Osi danej vrstvy je možné zobraziť/skryť použitím nasledujúcej funkcie:

l.enableAxis(int axis, on = True)

kde axis môže byť celé číslo od 0 do 3 alebo odpovedajúce vyhradené slovo:

0. Layer.Left - ľavá
1. Layer.Right - pravá
2. Layer.Bottom - dolná
3. Layer.Top - horná

    Ak je povolené zobrazovanie osi, je možné ju prispôsobiť skriptom v Pythone. Napríklad je možné nastaviť jej menovku:

l.setAxisTitle(axis, "My axis title")
l.setAxisTitleFont(axis, QtGui.QFont("Arial", 11))
l.setAxisTitleColor(axis, QtGui.QColor("blue"))
l.setAxisTitleAlignment(axis, alignFlags)
Alebo je možné zmeniť jej farbu a použitý typ písma:
l.setAxisColor(axis, QtGui.QColor("green"))
l.setAxisFont(axis, QtGui.QFont("Arial", 10))

    Stupnice osí môžu byť povolené alebo zakázané, je možné nastaviť ich farbu a uhol natočenia:

l.enableAxisLabels(axis, on = True)
l.setAxisLabelsColor(axis, QtGui.QColor("black"))
l.setAxisLabelRotation(axis, angle)

    Uhol angle môže byť celé číslo od -90 do 90 stupňov. Uhol natočenia je možné nastaviť iba pre horizontálne osi (dolnú a hornú).
    Formát čísla stupnice osi sa nastavuje použitím:

l.setAxisNumericFormat(axis, format, precision = 6, formula)

kde format môže nadobúdať nasledujúce hodnoty:

    Precision je počet význačných čísiel a formula je matematický výraz, ktorý môže byť použitý ako väzba protiľahlých stupníc. Jej argumentom musí byť x pre horizontálne osi a y pre vertikálne. Napríklad predpokladajme, že dolná os zobrazuje rozsah vlnových dĺžok v nanometroch a horná os reprezentuje odpovedajúce energie v eV. S pomocou nižšie uvedeného kódu budú všetky vlnové dĺžky automaticky konvertované na eV a výsledok sa zobrazí formou desatinného čísla s dvoma číslami za znakom desatinnej bodky:

l.setAxisNumericFormat(Layer.Top, 1, 2, "1239.8419/x")

    Dieliky osi môžu byť prispôsobované nasledujúcimi funkciami:

l.setTicksLength(minLength, majLength)
l.setAxisTicksLength(axis, majTicksType, minTicksType, minLength, majLength)

    Kde parametre majTicksType a minTicksType špecifikujú požadovanú orientáciu hlavných a vedľajších dielikov:

    MinLength špecifikuje dĺžku vedľajších dielikov v pixeloch a majLength dĺžku hlavných dielikov.
    Prispôsobiť rozsahy rôznych osí je možné použitím:

l.setScale(int axis, double start, double end, double step=0.0, int majorTicks=5, int minorTicks=5, int type=0, bool inverted=False);
kde type špecifikuje požadovaný typ stupnice:

0. Layer.Linear - lineárna
1. Layer.Log10 - logaritmická

    Step definuje veľkosť intervalu medzi hlavnými dielikmi osi. Ak nie je špecifikovaný (východzia hodnota je 0.0), tento krok je vypočítaný automaticky. Definovanie rozsahu osi neznamená, že sa automaticky zakáže autoscaling (automatická mierka). To znamená, že ak je niektorá krivka z vrstvy odstránená, osi sa automaticky prispôsobia novému intervalu. Je možné to zamedziť zakázaním módu autoscaling, potom sa však zakaždým uistite, že ste brali do úvahy nastavenia rozsahov:

l.enableAutoscaling(False)

    Ak chcete zmeniť mierku vrstvy grafu tak, aby boli viditeľné všetky údajové body, môžete použiť nasledovnú funkciu:

l.setAutoScale()

    Rovnaká funkcia ako bola uvedená vyššie, no s väčším počtom argumentov, môže vyzerať nasledovne:

l.setScale(axis, start, end, step=0.0, majorTicks=5, minorTicks=5, type=0, inverted=False, left=-DBL_MAX, right=DBL_MAX, breakPosition=50, stepBeforeBreak=0.0, stepAfterBreak=0.0, minTicksBeforeBreak=4, minTicksAfterBreak=4, log10AfterBreak=False, breakWidth=4, breakDecoration=True);

kde left špecifikuje hranicu oblasti prerušenia, right je pravá hranica, breakPosition je poloha prerušenia vyjadrená ako percento dĺžky osi a breakWidth je šírka oblasti prerušenia v pixeloch.
    Napokon je možné špecifikovať šírku všetkých osí a povoliť/zakázať vykreslenie ich hlavnej čiary použitím:

l.setAxesLinewidth(2)
l.drawAxesBackbones(True)


    7.2.9.4. Plocha grafu
    Okolo plochy grafu je možné zobraziť pravouhlé orámovanie a plochu grafu vyplniť farbou pozadia použitím:

l.setCanvasFrame(2, QtGui.QColor("red"))
l.setCanvasColor(QtGui.QColor("lightGrey"))

    Vykreslenie orámovania a zakázanie hlavných čiar osí je jediné možné riešenie problémy, aby sa osi na koncoch navzájom nedotýkali.


    7.2.9.5. Orámovanie vrstvy
    Okolo celej vrstvy je možné zobraziť pravouhlé orámovanie a taktiež je možné vrstvu vyplniť farbou pozadia použitím:

l.setFrame(2, QtGui.QColor("blue"))
l.setBackgroundColor(QtGui.QColor("grey"))

    Východzie medzery medzi okrajmi vrstvy a ďalšími prvkami (osi, menovka) je možné zmeniť príkazom:

l.setMargin(10)


    7.2.9.6. Prispôsobovanie mriežky
    Zobraziť mriežku súvisiacu s osou vrstvy alebo celú mriežku je možné použitím:

l.showGrid(axis)
l.showGrid()

    Zobrazí sa mriežka v prednastavenej farbe, šírke a ďalšími nastaveniami. Ak ich chcete zmeniť alebo povoliť/zakázať určité čiary mriežky, môžete použiť nasledujúce funkcie:

grid = l.grid()
grid.setMajPenX(QtGui.QPen(QtCore.Qt.red, 1))
grid.setMinPenX(QtGui.QPen(QtCore.Qt.yellow, 1, QtCore.Qt.DotLine))
grid.setMajPenY(QtGui.QPen(QtCore.Qt.green, 1))
grid.setMinPenY(QtGui.QPen(QtCore.Qt.blue, 1, QtCore.Qt.DashDotLine))
grid.enableXMax(True)
grid.enableXMin()
grid.enableYMax()
grid.enableYMin(False)
grid.enableZeroLineX(True)
grid.enableZeroLineY(False)
l.replot()

    Všetky funkcie mriežky používajú X v súvislosti s vertikálnymi čiarami mriežky, zatiaľ čo písmeno Y sa vzťahuje na horizontálne čiary. Výraz Maj sa vzťahuje na hlavné a Min na vedľajšie čiary mriežky.


    7.2.9.7. Legenda grafu
Do grafu je možné pridať novú legendu použitím príkazu:

legend = l.newLegend()
#alebo
legend = l.newLegend("enter your text here")

    Keď už raz vytvoríte legendu, je veľmi jednoduché ju prispôsobiť. Na zmenu textu je možné použiť:

l.setLegend("enter your text here")
#alebo
legend.setText("Enter your text here")

    Ďalšie vlastnosti legendy: farba textu, farba pozadia, štýl orámovania, druh písma a poloha ľavého horného rohu môžu byť zmenené nasledujúcimi funkciami:

legend.setTextColor(QtGui.QColor("red"))
legend.setBackgroundColor(QtGui.QColor("yellow"))
legend.setFrameStyle(Legend.Shadow)
legend.setFont(QtGui.QFont("Arial", 14, QtGui.QFont.Bold, True))
# nastavenie polohy ľavého horného rohu použitím súradníc v mierke grafu:
legend.setOriginCoord(200.5, 600.32)
# alebo nastavenie polohy ľavého horného rohu v pixeloch:
legend.setOrigin(5, 10)
l.replot()

    Ďalšie štýly orámovania dostupné pre legendu sú: LegendLine - vykreslí sa pravouhlé orámovanie textu a Legend.None pre legendu bez orámovania. Taktiež sú dostupné funkcie umožňujúce odstrániť pôvodnú legendu alebo funkcia pridania automatického časového údaja:

l.removeLegend()
l.addTimeStamp()


    7.2.9.8. Pridanie šípky/čiary do vrstvy grafu

arrow = ArrowMarker()
arrow.setStart(10.5, 12.5)
arrow.setEnd(200, 400.51)
arrow.setStyle(QtCore.Qt.DashLine)
arrow.setColor(QtGui.QColor("red"))
arrow.setWidth(1)
arrow.drawStartArrow(False)
arrow.drawEndArrow(True)
arrow.setHeadLength(7)
arrow.setHeadAngle(35)
arrow.fillArrowHead(True)

l = newGraph().activeLayer()
l.addArrow(arrow)


    7.2.9.9. Pridanie obrázkov do vrstvy grafu

l = newGraph().activeLayer()
image = l.addImage("C:/poze/adi/PIC00074.jpg")
image.setCoordinates(200, 800, 800, 200)
l.replot()

    Funkcia setCoordinates sa používa na nastavenie geometrie obrázku, pričom sa používajú súradnice v mierke vrstvy. Ak potrebujete špecifikovať geometriu obrázku v pixeloch, čiže nezávisle od hodnôt osí grafu, môžete použiť nasledujúce funkcie:

image.setOrigin(x, y)
image.setSize(width, height)
image.setRect(x, y, width, height)
l.replot()


    7.2.9.10. Zarovnávanie kriviek
    Zarovnávanie kriviek (antialiasing) môže byť povolené/zakázané pri vykresľovaní kriviek, prípadne iných objektov vrstvy, no ide o charakteristiku náročnú na výkon počítača:

l.setAntialiasing(True, bool update = True)


    7.2.9.11. Zmena veľkosti
    Prednastavené správanie sa vrstiev 2D grafov je také, že podľa zmeny veľkosti okna grafu prispôsobujú svoju veľkosť a aj veľkosť písma použitého v rozličných textových objektoch. Vyhnúť sa tomuto správaniu a ignorovať zmeny veľkosti okna je možné príkazmi:

l.setIgnoreResize(True)
l.setAutoscaleFonts(False)


    7.2.9.12. Exportovanie grafov/vrstiev do rôznych obrázkových formátov
    Z Pythonu môžu byť exportované vrstvy aj celé grafy. Najrýchlejším spôsobom, ako exportovať graf/vrstvu, je:

l.export(fileName)

    Táto funkcia používa pre vlastnosti obrázka niektoré predvolené parametre. Ak chcete mať väčšiu kontrolu na exportovanými obrázkami, môžete použiť niektorú zo špeciálnych funkcií:

l.exportVector(fileName, resolution = 96, color = True, keepAspect = True, pageSize = QtGui. QPrinter.Custom);
l.exportImage(filename, quality=100, transparent=False)

    Funkcia exportVector dokáže exportovať graf/vrstvu v nasledujúcich vektorových formátoch: .eps, .ps, .pdf. Nastavením premennej keepAspect na hodnotu True (je aj prednastavená) sa zachováva pomer šírky/výšky grafu aj v exportovanom obrázku. Má to ale jeden nedostatok, a to že niekedy sa okolo grafu vytvoria viditeľné biele okraje. Aby sa zabránilo týmto bielym okrajom, môžete nastaviť túto premennú na False a v tomto prípade bude graf prispôsobený veľkosti celej strany pageSize, takže spomínaný pomer sa zmení. QtiPlot primárne zvolí pageSize veľkosti, ktorá sa najlepšie hodí k reálnej veľkosti grafu, no veľkosť strany je možné aj zadefinovať: QtGui.QPrinter.A4, QtGui.QPrinter.A5, atď.
    Funkcia exportImage sa používa v prípade, že potrebujete exportovať obrázok v niektorom z podporovaných obrázkových formátov (.bmp, .png, .jpg, atď.). Voľba transparentného pozadia je použiteľná iba vo formátoch, ktoré takéto pozadie podporujú: .png a .tif (.tiff). Parameter quality ovplyvňuje veľkosť výstupného súboru. Čím je jeho hodnota vyššia (maximum je 100), tým vyššia bude kvalita obrázku, no tým väčšia bude aj veľkosť výstupného súboru.
    Jednotlivé funkcie je možné použiť v závislosti od prípony súboru, ktorá bola pre formát obrázku zvolená.

    Keď v jednom okne 2D grafu pracujete s viacerými vrstvami, ich manuálne usporiadanie môže byť veľmi zdĺhavé. S pomocou jednoduchého skriptu v Pythone je však táto úloha veľmi jednoduchá, pretože rozvrhnutie okna grafu je možné usporiadať automaticky. Tu je príklad usporiadanie vrstiev do dvoch riadkov a dvoch stĺpcov, pričom každá vrstva grafu má rozmer plochy grafu 400 pixelov na šírku a 300 pixelov na výšku:

g = newGraph("Test", 4, 2, 2)
g.setLayerCanvasSize(400, 300)
g.arrangeLayers(False, True)

    Funkcia arrangeLayers() má dva parametre. Prvý určuje, či má byť vrstva usporiadaná automaticky s použitím najvhodnejšieho algoritmu alebo je počet riadkov a stĺpcov fixne daný užívateľom. Ak je hodnota druhého parametra True, veľkosť plochy grafu je fixne daný užívateľom a okno grafu bude v závislosti od nastavení zväčšené alebo zmenšené. Inak bude veľkosť okna grafu zachovaná a plocha grafu každej vrstvy sa automaticky prispôsobí tak, aby tomuto rozmeru vyhovovala. Tu je spôsob ako modifikovať graf vytvorený v predošlom príklade, pričom vrstvy sa zobrazia v troch riadkoch a veľkosť okna grafu zostane nezmenená:

g.setNumLayers(3)
g.setRows(1)
g.setCols(3)
g.arrangeLayers(False, False)

    Predvolené je, že medzera medzi dvoma susednými vrstvami a tiež vzdialenosť vrstiev od okraja okna grafu je nastavená na 5 pixelov. Zmeniť medzeru medzi vrstvami a medzi vrstvou a okrajom je možné použitím nasledujúcich funkcií:

g.setSpacing (x, y)
g.setMargins (left, right, top, bottom)

    Ďalšou problematikou pri usporiadávaní vrstiev je ich zarovnanie. Dostupné sú tri možnosti horizontálneho zarovnania (HCenter, Left, Right) a ďalšie tri možnosti vertikálneho zarovnania (VCenter, Top, Bottom) vrstiev. Nasledujúci kód zarovná vrstvy na pravý roh okna a vertikálne ich vycentruje:

g.setAlignement(Graph.Right, Graph.VCenter)

    Vo všetkých predošlých príkladoch boli vrstvy zarovnané podľa mriežky, no samozrejme pridať vrstvy je možné do akejkoľvek časti okna grafu. V nižšie uvedenom príklade súradnice x, y sú v pixeloch a vzťahujú sa na polohu ľavého horného rohu vrstvy. Počiatok súradnicového systému sa zhoduje s ľavým horným oknom grafu, súradnica x narastá smerom dole. Ak je šírka a výška vrstvy nešpecifikovaná, nastavia sa predvolené hodnoty:

g = newGraph()
l1 = g.addLayer()
l2 = g.addLayer(10, 20, 200, 200)
l3 = g.addLayer(215, 20)

    Ako ste už mali možnosť vidieť, v okne grafu je ako aktívna vrstva nastavená posledná vrstva pridaná do grafu, no to je možné jednoducho zmeniť:

l = g.layer(num)
g.setActiveLayer(l)

    V prípade, že potrebujete vykonať tú istú úlohu pre všetky vrstvy okna grafu, potrebujete použiť slučku a samozrejme potrebujete vedieť počet existujúcich vrstiev v grafe. Tu je malý príklad znázorňujúci ako prispôsobiť menovky všetkých vrstiev okna grafu:

g = graph("Graph1")
layers = g.numLayers()
for i in range (1, layers+1):
    l = g.layer(i)
    l.setTitle("Layer"+QtCore.QString.number(i))
    l.setTitleColor(QtGui.QColor("red"))
    l.setTitleFont(QtGui.QFont("Arial", 14, QtGui.QFont.Bold, True))
    l.setTitleAlignment(QtCore.Qt.AlignLeft)

    No a napokon je niekedy užitočné vedieť vrstvy vymeniť. Spraviť tak je možné s pomocou nasledujúcej funkcie:

g.swapLayers(layerNum1, layerNum2)

    7.2.11.1. Vytvorenie 3D grafu
    3D graf je možné vytvoriť analytickou funkciou alebo parametricky. Pre 3D funkcie sú jedinými parametrami hodnoty x a y:

g = plot3D("sin(x*y)", -10.0, 10.0, -10.0, 10.0, -2.0, 2.0)

    Pre parametricky definované povrchové grafy sú jedinými povolenými parametrami šírka a dĺžka: u a v. Tu je príklad ako vytvoriť guľu:

g = plot3D("cos(u)*cos(v)", "sin(u)*cos(v)", "sin(v)", -3.14, 3.14, -2, 2)

    Taktiež je možné vytvoriť 3D výškové mapy, pričom budú použité údaje z matíc a samozrejme je možné vytvoriť grafy aj zo stĺpcov tabuľky:

g = plot3D(matrix("Matrix1"), style = 5)
g = plot3D(table("Table1"), "3", style)

    V prípade, že 3D graf bol vytvorený z údajov matice, parameter style môže byť hodnota od 1 do 5 s nasledovným významom:

    Pre 3D grafy vytvorené z údajov tabuľky má parameter style hodnoty od 0 do 3 alebo odpovedajúce slovné výrazy z nasledujúceho zoznamu:

    Alternatívnou metódou na vytvorenie 3D grafu je vytvorenie prázdneho okna a následné určenie zdrojových údajov pre graf. Už vieme, že zdrojom údajov môže byť analytická funkcia, matica alebo tabuľka. Pre prácu s veľkým množstvom údajov je niekedy vhodné urýchliť vykresľovanie redukovaním množstva údajov, ktoré sa budú brať do úvahy pri vykresľovaní. Čím menší je parameter rozlíšenia, tým vyšší počet údajov bude použitý: hodnota 1 znamená, že budú vykreslené všetky body.

g = newPlot3D()
g.setTitle("My 3D Plot", QtGui.QColor("blue"), QtGui.QFont("Arial",14))
g.setResolution(2)
g.setFunction("sin(x*y)", -10.0, 10.0, -10.0, 10.0, -2.0, 2.0)
#alebo
g.setData(table("Table1"), "3")
#alebo
g.setMatrix(matrix("Matrix1"))

    Keď je graf vytvorený, je možné meniť jeho mieru a nastavovať rozsah zobrazovaných údajov a to napríklad použitím:

g.setScales(-1.0, 1.0, -10.0, 11.0, -2.0, 3.0)


    7.2.11.2. Prispôsobovanie pohľadu
    Keď je vytvorený 3D graf, parametre pohľadu sú nastavené podľa predvolených hodnôt. QtiPlot poskytuje funkcie umožňujúce prispôsobiť každý uhol pohľadu. Napríklad ak chcete nastaviť uhly natočenia v stupňoch okolo osí X, Y a Z, použite:

g.setRotation(45, 15, 35)

    Nasledujúca funkcia umožňuje posunúť graf pozdĺž osí X, Y a Z:

g.setShift(3.0, 7.0, -4.0)

    Taktiež je možné priblížiť/oddialiť graf ako celok alebo vzhľadom na určitú os:

g.setZoom(10)
g.setScale(0.1, 0.05, 0.3)

    Automaticky zistiť hodnoty priblíženia/oddialenia, ktoré najviac vyhovujú veľkosti okna grafu, je možné príkazom:

g.findBestLayout()

    Povoliť/zakázať perspektívu alebo animácie je možné použitím:

g.setOrthogonal(False)
g.animate(True)


    7.2.11.3. Štýly grafu
    Štýl 3D grafu môže byť nastavený použitím nasledujúcich funkcií:

g.setPolygonStyle()
g.setFilledMeshStyle()
g.showLegend(True)
g.setHiddenLineStyle()
g.setWireframeStyle()
g.setAntialiasing(True)
g.setMeshLineWidth(0.7)

    Pre bodové grafy je možné špecifikovať polomer bodov a ich tvar: kružnice, ak smooth je nastavené na True, inak pravouholníky.

g.setDotOptions(10, smooth = True)
g.setDotStyle()

    Ďalšie symboly dostupné pre bodové grafy sú:

g.setCrossOptions(radius, width, smooth, boxed)
g.setCrossStyle()


    7.2.11.4. 2D projekcia
    Prednastavené je, že projekcia 3D grafu na spodnú stenu je zakázaná. Povoliť úplnú 2D projekciu alebo zobraziť len izočiary a následne vymazať projekciu je možné použitím funkcií:

g.showFloorProjection()
g.showFloorIsolines()
g.setEmptyFloor()


    7.2.11.5. Prispôsobovanie súradnicového systému
    Súradnicový systém v povrchovom grafe je možné prispôsobiť tak, že je zobrazených všetkých dvanásť osí, iba tri z nich alebo žiadna a to s pomocou nasledujúcich funkcií:

g.setBoxed()
g.setFramed()
g.setNoAxes()

    Ak sú osi povolené, ich legendu a vzdialenosť legendy od osí je možné nastaviť príkazmi:

g.setXAxisLabel("X axis legend")
g.setYAxisLabel("Y axis legend")
g.setZAxisLabel("Z axis legend")
g.setLabelsDistance(30)

    Taktiež je možné stanoviť fixnú dĺžku hlavných a vedľajších dielikov osi:

g.setXAxisTickLength(2.5, 1.5)
g.setYAxisTickLength(2.5, 1.5)
g.setZAxisTickLength(2.5, 1.5)


    7.2.11.6. Mriežka
    Ak je zobrazený súradnicový systém, je možné zobraziť v povrchovom grafe aj mriežku. Každá strana mriežky môže byť zobrazená/skrytá:

g.setLeftGrid(True)
g.setRightGrid()
g.setCeilGrid()
g.setFloorGrid()
g.setFrontGrid()
g.setBackGrid(False)


    7.2.11.7. Prispôsobovanie farieb grafu
    Farebná mapa grafu môže byť definovaná použitím dvoch farieb, jedna je pre maximálne hodnoty údajov a druhá pre minimálne hodnoty alebo je možné použiť komplexnejšiu farebnú mapu definovanú v súboroch .map. Takýto súbor pozostáva z 255 riadkov, pričom každý riadok definuje kód farby ako hodnotu RGB. Súbor preddefinovaných súborov farebných máp je možné stiahnuť aj z web stránky QtiPlot v sekcii "Miscelanous".

g.setDataColors(QtGui.QColor("red"), QtGui.QColor("orange"))
#alebo
g.setDataColorMap(fileName)
g.update()

    Farby všetkých ďalších prvkov grafu je možné upraviť podobne ako je to uvedené ďalej. Nezabúdajte aktualizovať graf, aby sa zobrazili nové farby:

g.setMeshColor(QtGui.QColor("blue"))
g.setAxesColor(QtGui.QColor("green"))
g.setNumbersColor(QtGui.QColor("black"))
g.setLabelsColor(QtGui.QColor("darkRed"))
g.setBackgroundColor(QtGui.QColor("lightYellow"))
g.setGridColor(QtGui.QColor("grey"))
g.setDataColors(QtGui.QColor("red"), QtGui.QColor("orange"))
g.setOpacity(0.75)
g.update()


    7.2.11.8. Exportovanie
    Spôsob ako exportovať 3D graf do obrázkového súboru je nasledovný:

g.export(fileName)
g.exportVector(fileName)
g.exportImage(fileName, int quality = 100, bool transparent = False)


    7.2.12. Analýza údajov


    7.2.12.1. Všeobecné funkcie
    Ako uvidíte v nasledujúcich častiach, dostupné operácie pre analýzu údajov v QtiPlot sú: konvolúcia/dekonvolúcia, korelácia, derivácia, FFT, filtrácia, vyhladzovanie, aproximácia a numerická integrácia. Vo všeobecnosti je možné deklarovať/inicializovať operáciu analýzy použitím jednej z nasledujúcich metód v závislosti od zdroja údajov, ktorým môže byť krivka 2D grafu alebo tabuľka:

op = FFTFilter(graph("Graph1").activeLayer(), "Table1_2", 1.5, 3.9)
op = LinearFit(table("Table1"), "colX", "colY", 10, 100)

    V prvom príklade je zdrojom údajov krivka Table1_2 vykreslená v aktívnej vrstve grafu Graph1 a rozsah hodnôt X bol zvolený od 1.5 do 3.9. V druhom príklade je zdrojom údajov tabuľka Table1. Údaje X sa nachádzajú v stĺpci nazvanom colX a hodnoty Y v stĺpci colY. Rozsah údajov bol zvolený v rozmedzí 10. riadok až riadok s indexom 100. Ak neurčíte rozsah, použitá bude celá tabuľka. Krivka ako zdroj údajov nemôže byť zvolená pre všetky operácie, napríklad pre konvolúciu/dekonvolúciu a koreláciu. Pre tieto operácie môžu byť použité len údaje zo stĺpcov tabuľky.
    Aj keď ste už inicializovali operáciu, stále je možné zmeniť vstupné údaje a to nasledujúcimi funkciami:

op.setDataFromCurve("Table1_energy", 10.5, 20.1, graph("Graph2").activeLayer())
op.setDataFromTable(table("Table1"), "colX", "colY", 10, 100)

    Ak už operácia bola inicializovaná špecifikovaním krivky v existujúcom grafe, vo funkcii setDataFromCurve() už nemusíte určiť vrstvu grafu, jedine že by ste chceli analyzovať inú krivku z tej istej vrstvy grafu.
    Keď robíte analytické úlohy cez skripty Pythonu, je dostupných niekoľko užitočných funkcií, ktoré môžu byť vyvolané pre všetky operácie. Napríklad je možné zakázať akýkoľvek grafický výstup operácie alebo je možné výstup presmerovať na vrstvu podľa vášho výberu:

op.enableGraphicsDisplay(False)
op.enableGraphicsDisplay(True, graph("Graph2").activeLayer())

    Predpokladajme, že potrebujete vykonať špecifickú operáciu op, ktorá analyzuje údaje a na konci zobrazí výslednú krivku. Pre takýto druh operácií je možné prispôsobiť počet bodov výslednej krivky a jej farbu:

op.setOutputPoints(int)
op.setColor(int)
op.setColor("green")

    Farby je možné špecifikovať ich názvami alebo celočíselnými hodnotami od 0 do 23, pričom každému číslu odpovedá preddefinovaná farba: 0 - "black" (čierna), 1 - "red" (červená), 2 - "green" (zelená), 3 - "blue" (modrá), 4 - "cyan" (zelenomodrá), 5 - "magenta" (purpurová), 6 - "yellow" (žltá), 7 - "darkYellow" (tmavožltá), 8 - "navy" (námornícka modrá), 9 - "purple" (fialová), atď.
    Vo väčšine prípadov sa ako výsledok údajovej analýzy vytvára aj nová tabuľka. Táto tabuľka obsahuje údaje zobrazené formou výslednej krivky a je prednastavené, že je skrytá, no interakcia je možná nasledujúcou funkciou:

t = op.resultTable()

    Po inicializácii analytickej operácie, ktorá pozostáva z určenia zdroja údajov, rozsahu údajov a niektorých ďalších vlastností ako farba, počet bodov atď., je možné vyvolať jej funkciu run():

op.run()

    Pre aproximačné operácie je obdobou funkcie run() funkcia fit().


    7.2.12.2. Korelácia, konvolúcia/dekonvolúcia
    Predpokladajme, že máme tabuľku pomenovanú "Table1", tak tu je spôsob, ako vypočítať konvolúciu jej dvoch stĺpcov "Table1_B" a "Table1_C":

conv = Convolution(table("Table1"), "B", "C")
conv.setColor("green")
conv.run()

    Dekonvolúcia a korelácia dvoch súborov údajov používa podobnú syntax:

dec = Deconvolution(table("Table1"), "B", "C")
dec.run()

cor = Correlation(table("Table1"), "B", "C", 10, 200)
cor.setColor("green")
cor.run()


    7.2.12.3. Derivácia
    Predpokladajme, že máme graf pomenovaný "Graph1" s krivkou nazvanou "Table1_2" (na aktívnej vrstve), tak tu je spôsob ako túto krivku derivovať na intervale x [2, 10]:

diff = Differentiation(graph("Graph1").activeLayer(), "Table1_2", 2, 10)
diff.run()

    Výsledkom tejto sekvencie kódov by bolo nové okno grafu zobrazujúce deriváciu pôvodnej krivky. Numerická derivácia sa počíta použitím vzorcov.


    7.2.12.4. FFT
    Predpokladajme, že máme graf pomenovaný "Graph1" s krivkou nazvanou "Table1_2" (na aktívnej vrstve) majúcou periodicitu 0.1 v časovej oblasti, FFT umožňuje určiť jej charakteristické frekvencie. Výsledok bude uložený v skrytej tabuľke pomenovanej "FFT1".

fft = FFT(graph("Graph1").activeLayer(), "Table1_2")
fft.normalizeAmplitudes(False)
fft.shiftFrequencies(False)
fft.setSampling(0.1)
fft.run()

    Predvolené je, že vypočítané amplitúdy sú normalizované a odpovedajúce frekvencie sú súmerné podľa osi x. Ak ale chceme získať počiatočnú krivku pomocou inverznej transformácie, nesmieme modifikovať amplitúdy a frekvencie. Taktiež parameter vzorkovania musí byť nastavený na inverznú časovú periódu, teda 10. Tu je spôsob ako vykonať inverznú FFT s použitím tabuľky "FFT1", aby sme získali pôvodnú krivku:

ifft = FFT(table("FFT1"), "Real", "Imaginary")
ifft.setInverseFFT()
ifft.normalizeAmplitudes(False)
ifft.shiftFrequencies(False)
ifft.setSampling(10)
ifft.run()


    7.2.12.5. FFT filtre
    V tejto časti budeme predpokladať, že máme signál (údaje sú v "Table1_2") zobrazený v grafe ("Graph1", na jeho aktívnej vrstve). Tento signál má spektru s vysokými a nízkymi frekvenciami. Niektoré z týchto frekvencií je možné podľa potreby filtrovať použitím FFT filtra. Tu je spôsob ako odstrániť všetky frekvencie menšie ako 1 Hz:

filter = FFTFilter(graph("Graph1").activeLayer(), "Table1_2", FFTFilter.HighPass)
filter.setCutoff(1)
filter.run()

    Tu je spôsob ako odstrániť všetky frekvencie menšie ako 1.5 Hz a väčšie ako 3.5 Hz. V nasledujúcom príklade je odstránená aj opakujúca sa zložka signálu:

filter.setFilterType(FFTFilter.BandPass)
filter.enableOffset(False)
filter.setBand(1.5, 3.5)
filter.run()

    Ďalšie typy FFT filtrov dostupné v QtiPlot sú dolnopriepustný (FFTFilter.LowPass) a filter na odstránenie pásma (FFTFilter.BandBlock).


    7.2.12.6. Aproximácia
Predpokladajme, že máme graf pomenovaný "Graph1" s krivkou s názvom "Table1_2" (na jeho aktívnej vrstve), príklad aproximácie by bol:

f = GaussFit(graph("Graph1").activeLayer(), "Table1_2")
f.guessInitialValues()
f.fit()

    Vytvorí sa nový objekt GaussFit. Podporované sú nasledujúce typy aproximácie:

f = PluginFit(layer, curve)
f.load(pluginName)


    Pre každú z nich je možné zvoliť obmedzenie rozsahu X, ktoré bude pri aproximácii použité, napríklad

f = LinearFit(graph("Graph1").activeLayer(), "Table1_2", 2, 7)
f.fit()

    Taktiež je možné obmedziť rozsah pre akýkoľvek parameter aproximácie:

f = NonLinearFit(graph("Graph1").activeLayer(), "Table1_2")
f.setParameters("a0", "a1", "a2")
f.setFormula("a0+a1*x+a2*x*x")
f.setParameterRange(parameterIndex, start, end)

    Všetky nastavenia nelineárnej aproximácie môžu byť uložené do XML súboru a z tohto súboru potom neskôr znovu otvorené, čím sa urýchli proces editovania. Tu je príklad ako uložiť funkciu uvedenú vyššie:

f.save("/fit_models/poly_fit.txt")

    A následne ako neskôr použiť tento súbor pre inú aproximáciu:

f = NonLinearFit(graph("Graph1").activeLayer(), "Table1_2")
f.load("/fit_models/poly_fit.txt")
f.fit()

    Po vytvorení objektu aproximácie a pred vyvolaním fit() je možné nastaviť rôzne parametre ovplyvňujúce aproximáciu:

f.setDataFromTable(table("Table4"), "w", "energy", 10, 200) - zmení zdroj údajov
f.setDataFromCurve(curve) - zmení zdroj údajov
f.setDataFromCurve(curve, graph) - zmení zdroj údajov
f.setDataFromCurve(curve, from, to) - zmení zdroj údajov
f.setDataFromCurve(curve, from, to, graph) - zmení zdroj údajov
f.setInterval(from, to) - zmení rozsah údajov
f.setInitialValue(number, value)
f.setInitialValues(value1, ...)
f.guessInitialValues()
f.setAlgorithm(algo) # algo = Fit.ScaledLevenbergMarquardt, Fit.UnscaledLevenbergMarquardt, Fit.NelderMeadSimplex
f.setWeightingData(method, colname) # method = Fit.NoWeighting, Fit.Instrumental, Fit.Statistical, Fit.Dataset
f.setTolerance(tolerance)
f.setOutputPrecision(precision)
f.setMaximumIterations(number)
f.scaleErrors(yes = True)
f.setColor("green") - zmení farbu výslednej aproximovanej krivky na zelenú (prednastavená je červená)

    Po vyvolaní funkcie fit() je množstvo možností určených pre výsledky:

f.results()
f.errors()
f.chiSquare()
f.rSquare()
f.dataSize()
f.numParameters()
f.parametersTable("params")
f.covarianceMatrix("cov")

    Je dôležité vedieť, že QtiPlot dokáže vygenerovať analytický zápis výslednej krivky aproximácie alebo krivku s údajmi uloženými v skrytej tabuľke. Zvoliť ktorúkoľvek z týchto možností je možné pred vyvolaním funkcie fit() použitím:

f.generateFunction(True, points=100)

    Ak je v tejto funkcii prvý parameter nastavený ako True, QtiPlot vygeneruje krivku analytickej funkcie. Ak je parameter points nešpecifikovaný, funkcia bude stanovená pre viac ako 100 bodov. Analytický zápis krivky je možné získať príkazom resultFormula():

formula = f.resultFormula()
print(formula)

    Ak je prvý parameter v generateFunction() nastavený ako False, QtiPlot vytvorí skrytú tabuľku s údajmi obsahujúcimi rovnaký počet bodov aký mala krivka, ktorú bolo potrebné aproximovať. Prepojenie s touto tabuľkou a prezeranie údajových bod výslednej aproximovanej krivky je možné použitím:

t = f.resultTable()


    7.2.12.7. Integrácia
    Za rovnakých podmienok ako boli uvedené vyššie nasleduje príklad ako je možné integrovať krivku v rámci daného intervalu:

integral = Integration(graph("Graph1").activeLayer(), "Table1_2", 2, 10)
integral.setMethodOrder(4)
integral.setTolerance(1e-4)
integral.setMaximumIterations(100)
integral.run()
result = integral.area()

    Parameter metódy môže byť celé číslo s hodnotou od 1 (lichobežníkové pravidlo, prednastavené) do 5. Zápisom sa krivka integruje použitím iteračného algoritmu. Tolerancia stanovuje kritériá výsledku pre riešiteľa. Z dôvodu, že niekedy je potrebná vysoká presnosť, nastavením maximálneho počtu iterácií sa uistíme, že riešiteľ nemôže zadať nekonečný cyklus, ktorý by spôsobil zmrznutie aplikácie.
    Ako je možné vidieť na predošlom príklade, numerická hodnota integrálu môže byť získaná funkciou area().


    7.2.12.8. Interpolácia
    Interpolácia sa používa na vygenerovanie novej krivky s vyšším počtom bodov ako mal existujúci súbor údajov. Tu je príklad:

interpolation = Interpolation(graph("Graph1").activeLayer(), "Table1_2", 2, 10, Interpolation.Linear)
interpolation.setOutputPoints(10000)
interpolation.setColor("green")
interpolation.run()

    Najjednoduchšou interpolačnou metódou je metóda lineárna. Dostupné sú ale aj ďalšie dve metódy: Interpolation.Akima a Interpolation.Cubic. Zvoliť si interpolačnú metódu je možné použitím:

interpolation.setMethod(Interpolation.Akima)


    7.2.12.9. Vyhladzovanie
    Predpokladajme, že máme graf pomenovaný "Graph1" s nepravidelnou krivkou nazvanou "Table1_2" (na aktívnej vrstve). Vyhladiť túto krivku je možné použitím funkcie SmoothFilter:

smooth = SmoothFilter(graph("Graph1").activeLayer(), "Table1_2", SmoothFilter.Average)
smooth.setSmoothPoints(10)
smooth.run()

    Predvolená je metóda plávajúceho priemeru. Ďalšími dostupnými metódami sú SmoothFilter.FFT a SmoothFilter.SavitzkyGolay. Príklad použitia poslednej metódy:

smooth.setSmoothPoints(5,5)
smooth.setMethod(SmoothFilter.SavitzkyGolay)
smooth.setPolynomOrder(9)
smooth.run()

    Predpokladajme, že máme analyzovať množstvo ASCII súborov. Okrem toho predpokladajme, že tieto súbory boli vytvorené sériou meraní, každým meraním sa vytvorila sada súborov označených určitým reťazcom v názve súboru, napríklad "disper1". Aby bolo možné analyzovať tieto súbory, najskôr je potrebné ich importovať do tabuliek. Nasledujúci kód je príkladom ako takúto úlohu automatizovať použitím dialógov Qt a vhodných tried:

    Pre detailný opis dialógov a tried dostupných v Qt/PyQt pozrite dokumentáciu PyQt documentation.