# OMRnotes.scripts.classification package

## Subpackages

- OMRnotes.scripts.classification.find package
  - Submodules
  - OMRnotes.scripts.classification.find.halfheads module
  - OMRnotes.scripts.classification.find.heads module
  - Module contents

## Submodules

## OMRnotes.scripts.classification.dist module

class `OMRnotes.scripts.classification.dist.``Distance`(ccs1, ccs2)

  Vypocet vzdalenosti mezi jednotlivymi segmenty

  vystup:

  z - absolutni hodnota vzdalenosti od stredu obou segmentu

  angle - uhel mezi centry segmentu ve stupnich

  ul_x,ul_y - horni levy roh spojenych sementu

  lr_x,lr_y - spodni pravy roh spojenych segmentu

  d - segment

  zup - vzdalenost od vrchu prvniho segmenu od stredu druheho segmentu

  angleup - vzdalenost od vrchu prvniho segmenu od stredu druheho segmentu

  zdown - vzdalenost od spodu prvniho segmenu od stredu druheho segmentu

  anledown - uhel od spodu prvniho segmenu od stredu druheho segmentu

## OMRnotes.scripts.classification.dot module

class `OMRnotes.scripts.classification.dot.``Dot`

  Detekce tecky u noty na zaklade tvaru a vzdalenosti

  `dot` = None
  `haveDot`(imgseg, sf)

## OMRnotes.scripts.classification.halfhead module

class `OMRnotes.scripts.classification.halfhead.``Halfheads`(index1, index2, seghead, segline, distance, dir)

  Bases: `OMRnotes.scripts.classification.dot.Dot`

  Pulove noty

  `dot` = None
  `flag` = None

## OMRnotes.scripts.classification.head module

class `OMRnotes.scripts.classification.head.``Head`(head, center_x, center_y, pitch)

  Hlavicka noty

class `OMRnotes.scripts.classification.head.``Heads`(index1, index2, seghead, segline, distance, dir, lines, dur)

  Bases: `OMRnotes.scripts.classification.dot.Dot`

  Harmonicky spojene hlavicky not.

  Vypocitava linku, ktere nota nalezi, podle toho je indexovana

  Index 0 znaci posledni linku

  O pultonu nize je index -1

  O pultonu vyse je index 1

  `addHead`(seghead)

    Pridava spravne detekovanou hlavicku do seznamu harmonickych spojeni

  `addnote`(seghead)

    Spoji hlavicky do harmocicke podoby

  `haveFlag`(imgseg, sf)

    Testuje zda nota ma praporek

  `isBeam`(seg)

    Testuje, zda se hlavicka s linkou dotykaji

class `OMRnotes.scripts.classification.head.``Quaters`(lines)

  Datova struktura pro vsechny harmonicky spojene hlavicky not

  `append`(heads)

    Test slouceni hlavicek not do harmonicke podoby

    Tesetuje, zda hlavicky nalezi stejne lince

## OMRnotes.scripts.classification.lines module

class `OMRnotes.scripts.classification.lines.``LineArgs`(left_x, y_list, i, j)

  Model linky aproximovany polynomialni funkci

class `OMRnotes.scripts.classification.lines.``Lines`(linelist, staffline_height, staffspace_height)

  Datova struktura pro vsechny detekovane linky

  static `checkLines`(linelist)

    Overuje zda je pocet detekovanych linek na radku roven 5

    checkerr - pocet chybnych radku

  `finder`(y)

    Rychlejsi detekce vzdalenosti mezi linkou a bodem

    return[0] - odsazeni nejblizsi linky

    return[1] - prumerna poloha linky v ose y

  `touch`(point, staff=None)

    Datova struktura pro detekci vzdalenosti mezi linkou a bodem

    return[0] - cislo radku nejblizsi detekovane linky

    return[1] - cislo linky nejblizsi detekovane linky

    return[2] - vzdalenost od nejblizsi detekovane linky

## OMRnotes.scripts.classification.searcher module

class `OMRnotes.scripts.classification.searcher.``Searcher2`(range, img, imgrot, angle, sub, jump, black)

  Algoritmus pro trasovani trajektorii linek v jakemkoli uhlu. Moznost pouziti jakehokoli uhlu zajistuje natoceni obrazu v zadanem smeru a pouziti trasovani v sestupnem smeru. Rotace obrazu zmeni souradnice vstupniho bodu. Natoceni obrazu knihovnou GAMERA automaticky prizpusobi okraje obrazku a je potreba tuto skutecnost zahrnout do rovnice transformace. Pro jine uhly jak nasobky 90 knihovna pridava offset 2px od okraje.

  Vstupy:

  range - startovni sledovaci body

  img - vstupni obrazek

  imgrot - rotovany obrazek

  angle - uhel o ktery je obrazek rotovany

  sub - sirka sledovaciho kanalu

  jump - maximalni delka bile mezery (preruseni linky)

  black - minimalni pocet cernych pixelu v kanalu

  `detransformpoint`(points)

    Vypocet zpetne afinni transformace rotace pro jeden bod v obraze, ktery ma orezane okraje

  `search2`(maxlen)

    Trasovani probiha smerem dolu v sirce sledovaciho kanalu po vsechny body. Algoritmus postupuje, dokud neni prekrocena podminka maximalni mezery. Cerne pixely v radku nesplnujici podminku stanoveneho minimalniho poctu jsou povazovany za bile. Vysledna stanocena delka je ve vzdalenosti od pocatku do posledni platne detekce cernych pixelu. Algoritmus take urci pribliznou horizontalni polohu stredu linky, na zaklade nejcasteji se vyskytujicich cernych pixelu v kanalu.

    Vystupy:

    list argumentu

    Hodnoty v indexech jednoho argumentu pro jeden bod:

    argument[0] - vzdalenost

    argument[1] - zpetne transformovany pocatecni bod

    argument[2] - index bodu

    argument[3] - faul - primost linky

    argument[4] - zpente transformovany konecny bod linky

    > x - stredni vyskyt cernych pixelu v horizontalni poloze

    > y - konecna poloha linky

  `transformpoint`(points)

    Vypocet afinni transformace rotace pro jeden bod v obraze, ktery ma orezane okraje

## OMRnotes.scripts.classification.seg module

class `OMRnotes.scripts.classification.seg.``Seg`(ul_x, ul_y, lr_x, lr_y)

  Segment obrazku. Reprezentovan je dvemi krajnimi body, vyskou, sirkou a centralnim bodem

  static `combine`(seg)

    Spojeni dvou segmentu minimalizaci a maximalizaci krajnich bodu

## OMRnotes.scripts.classification.segmenter module

class `OMRnotes.scripts.classification.segmenter.``Segmenter`

  Segmentacni trida

  `deletebeams`(beams, img)

    Odstraneni tramcu

  `deletefullnotes`(heads, beams, img)

    Odstraneni not s plnou hlavickou vcetne praporku a tecky

  `deletehalfnotes`(halfheads, img)

    Odstraneni pulovych not

  `deleteheads`(heads, img)

    Odstraneni not s hlavicek plnych not

  `deleteheadslines`(heads, img)

    Odstraneni not s hlavicek a linek plnych not

  `deletesegments`(seg, img)

    Odstraneni segmentu

  `findbeams`(heads, orig)

    detekce tramcu

  `findlines`(imgline, img)

    Hledani linek v obraze

  `getcc`(img)

    Analyza metodou spojenych komponent

  `getdots`(headlist, imgcc, delcc, sf)

    detekce tecek

  `getflags`(headlist, imgcc, delcc, sf)

    detekce praporku

  `subcc`(imgcc, imgsubcc, iter)

    spojeni dvou segmentu vnorenych v sobe

`OMRnotes.scripts.classification.segmenter.``rand`(d0, d1, ..., dn)

  Random values in a given shape.

  Create an array of the given shape and populate it with random samples from a uniform distribution over `[0, 1)`.

  d0, d1, ..., dn : int, optional
    The dimensions of the returned array, should all be positive. If no argument is given a single Python float is returned.
  out : ndarray, shape `(d0, d1, ..., dn)`
    Random values.

  random

  This is a convenience function. If you want an interface that takes a shape-tuple as the first argument, refer to np.random.random_sample .

      >>> np.random.rand(3,2)
      array([[ 0.14022471,  0.96360618],  #random
             [ 0.37601032,  0.25528411],  #random
             [ 0.49313049,  0.94909878]]) #random

`OMRnotes.scripts.classification.segmenter.``randn`(d0, d1, ..., dn)

  Return a sample (or samples) from the “standard normal” distribution.

  If positive, int_like or int-convertible arguments are provided, randn generates an array of shape `(d0, d1, ..., dn)`, filled with random floats sampled from a univariate “normal” (Gaussian) distribution of mean 0 and variance 1 (if any of the are floats, they are first converted to integers by truncation). A single float randomly sampled from the distribution is returned if no argument is provided.

  This is a convenience function. If you want an interface that takes a tuple as the first argument, use numpy.random.standard_normal instead.

  d0, d1, ..., dn : int, optional
    The dimensions of the returned array, should be all positive. If no argument is given a single Python float is returned.
  Z : ndarray or float
    A `(d0, d1, ..., dn)`-shaped array of floating-point samples from the standard normal distribution, or a single such float if no parameters were supplied.

  random.standard_normal : Similar, but takes a tuple as its argument.

  For random samples from , use:

  `sigma * np.random.randn(...) + mu`

      >>> np.random.randn()
      2.1923875335537315 #random

  Two-by-four array of samples from N(3, 6.25):

      >>> 2.5 * np.random.randn(2, 4) + 3
      array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],  #random
             [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]]) #random

## Module contents