MVTools

Přehled

autor: Manao, Fizick(Aleksandr Balachnin), Tsp, TSchniede
verze: 1.11.4.5
stáhnout: http://avisynth.org.ru/, http://www.avisynth.org/warpenterprises/
kategorie: Různé pluginy
požadavky: YV12 nebo YUY2 Barevné prostředí
licence: GPL

Obsah

I) O pluginu MVTools

MVTools - plugin pro AviSynth 2.5 je kolekce funkcí pro odhadnutí a kompenzaci pohybu objektů ve video klipech. Kompenzace pohybu může být použita pro silné časové (temporal) odšumění, pokročilé převody snímkových frekvencí, restauraci obrazu a další úlohy.

Plugin obsahuje server-funkci odhadu pohybu MVAnalyse pro nalezení vektorů pohybu a několik klient-funkcí kompenzace pohybu (MVCompensate, MVMask a další) které používají tyto vektory.

Plugin používá metodu srovnávání bloků pro odhad pohybu (podobné metody jsou použity v MPEG2, MPEG4, atd). Ve fázi analýzy plugin rozděluje snímky na malé bloky a snaží se najít pro každý blok v aktuálním snímku nejpodobnější (odpovídající) blok v druhém snímku (předchozím nebo následujícím). Relativní posunutí těchto bloků je vektor pohybu. Hlavním měřítkem podobnosti bloků je součet absolutních rozdílů (SAD) všech pixelů těchto dvou porovnávaných bloků. SAD je hodnota, která říká, jak dobrý byl odhad pohybu.

Výstupem MVAnalyse (server) je speciální klip s informacemi o vektorech pohybu v nějakém formátu.

Ve fázi kompenzace klient-funkce pluginu čtou vektory pohybu a použijí je k vyjmutí bloků a zformování snímku s kompenzovaným pohybem (nebo realizuje nějakou jinou plnou nebo částečnou kompenzaci pohybu nebo funkci interpolace). Každý objekt (blok) v tomto (plně) kompenzovaném snímku je umístěn na stejnou pozici v jaké je v aktuálním snímku. Tedy, můžeme (například) použít silné časové odšumění dokonce pro docela rychle se pohybující objekty bez vytváření nepříjemných artefaktů a duchů (rysy objektu a hrany jsou shodné pokud je kompenzace perfektní). Plugin může vytvořit kompenzované sousední snímky pro každý aktuální snímek, a odstranit v nich šum vnitřní funkcí (MVDenoise). Nebo můžete použít kompenzované a původní snímky k vytvoření prolínaného (interleaved) klipu, odstranit v nich šum jakýmkoliv externím časovým (temporal) filtrem, a vybrat centrální vyčištěné původní snímky pro výstup (viz příklady).

Odhad pohybu a jeho kompenzace nejsou samozřejmě ideální a dokonale přesné. V některých komplikovaných případech (video se stmíváním - fading, ultra-rychlého pohybu, nebo periodických struktur) může být odhad pohybu zcela chybný, a kompenzovaný (obzvláště interpolovaný) snímek může být kostkatý a (nebo) ošklivý. Těžké potíže jsou také kvůli vzájemnému zastínění jednoho objektu druhým nebo obráceně odkrývání. Složité Avisynth skripty s řadou funkcí pro kompenzaci pohybu mohou spotřebovat velký objem paměti a výsledkem je velmi pomalé zpracování. Nejedná se o jednoduchý, ale o docela pokročilý plugin. Používejte ho jen ve vhodných případech a snažte se vyladit jeho parametry. Existuje mnoho diskuzí o použití kompenzace pohybu na doom9 Avisynth fóru. Především se podívejte na starší vlákno MVTools, vlákno true motion, nové vlákno MVTools a některá další. Snažte se číst příspěvky jako doplněk této dokumentace a žádejte zde o pomoc. Pokud se skutečně zajímáte o témata odhadu a kompenzace pohybu, můžete snadno najít řadu vědeckých publikací (použijte WWW vyhedávání).

Poznámky: Plugin je stále ve vývoji. Aktuální verze má některá omezení. Podporováno je jen progresivní YV12, YUY2 video. Použijte převod barevného formátu a zkuste použít (smart) bob-deinterlace pro prokládané video (může také pracovat rozdělení na pole SeparateFields s nebo bez SelectEven/SelectOdd). Některé komplikované skripty (MVBOB, MCBOB) používají MVTools pro odstranění prokládání s kompenzací pohybu.

Alternativně můžete zkusit použít plugin Motion od mg262.

II) Popisy funkcí

Běžné parametry

Filtry, které používají vektory pohybu mají běžné parametry. Ty jsou prahovými hodnotami detekce změny scény, a mají znaky mmx / isse. Také používají jeden nebo více vektorových streamů, které jsou vytvářeny funkcí MVAnalyse.

int thSCD1 : prahová hodnota, která rozhoduje, zda se blok změnil mezi předchozím snímkem a aktuálním. Když se blok změnil, znamená to, že odhad pohybu pro toto není významný. To nastává například při změně scény. Tedy to je jedna z prahových hodnot použitých k nastavení mechanismu změny scény. Jeho zvětšení sníží počet bloků detekovaných jako změněné. Může to být užitečné pro zašumělé nebo blikající video. Prahová hodnota je porovnána s hodnotou SAD (Sum of Absolute Differences - součet absolutních rozdílů, hodnotou, která říká jak špatný byl odhad pohybu ). Pro přesně identické bloky máme SAD=0. Ale skutečné bloky se vždy liší kvůli složitému pohybu objektů (přiblížení, rotaci, deformaci), diskrétnosti vzorkování pixelů, a šumu. Předpokládejme, že máme dva porovnané bloky 8x8 s každým pixelem lišícím se o 5. V tomto případě bude SAD 8x8x5 = 320 (blok nebude detekován jako změněný pro thSCD1=400). Pokud použijete bloky 4x4, SAD bude 320/4. Pokud použijete bloky 16x16, SAD bude 320*4. Ve skutečnosti se tento parametr násobí vnitřně v MVTools, a vy musíte vždy použít hodnotu redukovanou na velikost bloku 8x8. Výchozí je 400 (od v.1.4.1).

int thSCD2 : prahová hodnota, která nastavuje kolik bloků ve snímku se musí změnit aby se rozhodlo, že se jedná o změnu scény. Je to v rozsahu 0 až 255, 0 znamená 0 %, 255 znamená 100 %. výchozí je 130 ( což znamená 51 % ).

bool isse : znak, který umožňuje vypnout ISSE a MMX optimalizace pokud se nastaví na false (pro odladění). Výchozí je true. Pokud váš procesor nepodporuje ISSE MMX optimalizace, bude to každopádně vypnuto ( a vy nebudete schopni je aktivovat )

MVAnalyse

MVAnalyse (clip, int "blksize", int "blksizeV", int "pel", int "level", int "search", int "searchparam", int "pelsearch", bool "isb", int "lambda", bool "chroma", int "delta", bool "truemotion", int "lsad", int "pnew", int "plevel", bool "global", int "pzero", int "overlap", int "overlapV", string "outfile", int "sharp", int "rfilter", clip "pelclip", int "dct", int "divide", bool "mc", int "idx", int "sadx264")

Odhaduje pohyb metodou srovnávání bloků a vytváří speciální výstupní klip s daty vektorů pohybu (používané dalšími funkcemi).
Jsou implementovány některé hierarchické víceúrovňové metody vyhledávání (od hrubého měřítka obrazu k nejjemnějšímu). Funkce používají nulový vektor a vektory sousedních bloků jako prediktory (předpovědi) pro aktuální blok. Nejdříve je odhadnuta odchylka (SAD) pro prediktory, pak se zkušební vektor (kandidát) změnění o nějakou hodnotu v některém směru, odhaduje se SAD, atd. Přijatý nový vektor je vektor s minimální hodnotou SAD (s nějakou penalizací na soudržnost pohybu).

blksize : Velikot bloku (horizontální). Je buď 4, 8 nebo 16 ( výchozí je 8 ). Větší bloky jsou méně citlivé na šum, jsou rychlejší, ale také méně přesné.

blksizeV : vertikální velikost bloku. Výchozí je rovna horizontální velikosti. Doplňkové možnosti: 4 pro blksize=8 a 8 nebo 2 pro blksize=16.

pel : je přesnost odhadu pohybu. Hodnota může být jen 1, 2 nebo 4. 1 znamená přesnost na pixel. 2 znamená přesnost na půl pixelu, 4 znamená přesnost na čtvrtinu pixelu, tvořenou prostorovou (spatial) interpolací (přesnější ale pomalejší a ne vždy lepší kvůli velkému kroku násobení mezi úrovněmi). Výchozí je 2 od v1.4.10.

level : je počet Nepoužitých hrubých úrovní v hierarchické analýze prováděné při vyhledávání vektorů pohybu. Obvykle čím nižší, tím lepší (lze nalézt vektory s jakoukoliv délkou). Proměnná je zachována pro studijní (testovací) účely. Někdy je level užitečný pro vyloučení velkých (lživých) vektorů (počítačové grafiky, atd). Výchozí : 0 (jsou použity všechny úrovně).

search, searchparam, pelsearch : search určuje typ vyhledávání v každé úrovni, a searchparam je přídavný parametr (krok, rádius) pro toto vyhledávání, a pelsearch je parametr na nejjemnější (pel) úrovni:

isb : umožní volit mezi dopředným vyhledáváním (pohyb z předchozího snímku do aktuálního) pro isb=false a zpětným vyhledáváním (pohyb z následujícího snímku do aktuálního) pro isb=true (isb znamená "IS Backward", je to implementováno a nazváno přesně tak jak je zde popsáno, neptejte se na to :-). Výchozí je isb=false.

chroma : nastavení na true umožní zahrnout také barevnost při odhadu pohybu (false - pouze jas). Výchozí je true.

delta : nastavuje interval snímků mezi referenčním snímkem a aktuálním snímkem. Výchozí je 1, což znamená, že vektory pohybu jsou vyhledávány mezi aktuálním snímkem a předchozím ( nebo dalším ) snímkem. Nastavení na 2 vám umožní vyhledávat vektory pohybu mezi snímkem n a n-2 nebo n+2 ( v závislosti na nastavení isb ).

Existuje několik pokročilých parametrů, které nastavují souvislost vektorů pohybu pro odhad takzvaného skutečného pohybu (true motion). Některé porovnané bloky z jiného snímku mohou být nejpodobnější vzorovým blokům aktuálního snímku podle kriteria intenzity (SAD), ale neodpovídají skutečnému pohybu objektu. Například, mohou příslušet jinému podobnému objektu v jiném rohu snímku nebo nějaké periodické struktuře. Parametry "True motion" se snaží udržet pohybová pole více soudržná, namísto některých náhodných distribucí vektorů. Je to obzvlášť důležité pro jednotlivé kompenzace pohybu a interpolace. Některé parametry jsou experimentální a mohou být odstraněny (nahrazeny) v příštích verzích po vyzkoušení. Oznamujte prosím své závěry.

truemotion je přednastavení hodnot těchto parametrů. Umožňuje snadno přepnout výchozí hodnoty všech "true motion" parametrů najednou. Nastavte true pro vyhledávání skutečného pohybu - true motion (vyšší soudržnost vektorů), Nastavte false pro vyhledávání vektorů pohybu s nejlepší SAD. Výchozí je true od v1.4.10. V každém případě můžete nastavit každý parametr samostatně.

lambda : nastavuje soudržnost polí vektorů. Čím vyšší, tím soudržnější. Nicméně, pokud je příliš vysoký, mohou být některé nejlepší vektory pohybu opomenuty. Velmi se doporučují hodnoty kolem 400 - 2000 (pro velikost bloku 8). Vnitřně je to koeficient pro penalizaci (úpravu) SAD od kvadratického rozdílu vektoru od prediktoru (sousedů), násobeným 256.
Výchozí je 0 pro truemotion=false a 1000*blksize*blksizeV/64 pro truemotion=true.

lsad: SAD limit pro použití lambda . Lokální lambda je sníženo (plynule od v1.10.2) pokud hodnota SAD vektoru prediktoru (zhotovená ze sousedních bloků) je větší než tento limit. Brání to použití špatných prediktorů, ale snižuje soudržnost pohybu. Pro skutečný pohyb (true motion) jsou doporučeny hodnoty nad 1000 (pro velikost bloku=8).
Výchozí je 400*blksize*blksizeV/64 pro truemotion=false a 1200*blksize*blksizeV/64 pro truemotion=true.

pnew: relativní penalizace (násobena 256) k odchylce (SAD) nového kandidujícího vektoru. Nový kandidující vektor musí být lepší, aby byl přijat jako nový vektor jen, když jeho SAD s penalizací (SAD + SAD*pnew/256) jen nižší než odchylka prediktoru (staré SAD). To brání nahrazení docela dobrých prediktorů novými vektory s o trochu lepším SAD ale jinou délkou a směrem.
Výchozí je 0 pro truemotion=false a 50 pro truemotion=true.

plevel: režim násobení penalizačního koeficientu lambda úrovně. Hodnota=0 - bez násobení, 1 - lineární, 2 - kvadratická závislost na velikosti hierarchické úrovně. Všimněte si, že délka vektoru je menší na nižší úrovni.
Výchozí je 0 pro truemotion=false a 1 pro truemotion=true

global: odhaduje globální pohyb (v každé úrovni) a používá ho jako doplňkový prediktor. Je odhadován pouze (panoramatický) posun kamery (ne přibližování ani rotace). Použijte false pro vypnutí, použijte true pro zapnutí. Výchozí je false pro truemotion=false a true pro truemotion=true.

pzero: relativní penalizace (násobena 256) k odchylce (SAD) pro nulový (a globální) vektor. Brání nahrazení docela dobrých prediktorů nulovými vektory s o trochu lepší SAD (lambda se pro nulové a globální vektory nepoužívá). Výchozí je roven pnew od v1.11.

overlap: hodnota překrytí bloků (horizontální). Musí být sudá a menší než velikost bloku (do blksize/2 pro MVCompensate). Krok mezi bloky pro odhad pohybu je roven (blksize-overlap). N bloků pokrývá velikost ((blksize-overlap)*N + overlap) na snímku. Zkuste použít hodnotu překrytí od blksize/4 do blksize/2. Čím větší překrytí, tím větší počet bloků, a tím menší rychlost zpracování. Výchozí hodnota je 0.
Funkce s podporou překrytí jsou: MVFlow, MVFlowInter, MVFlowFps (ne MVFlowFps2), MVShow, MVMask, MVCompensate, MVDeGrain1, MVDeGrain2, MVDeGrain3.

overlapv: vertikální hodnota překrytí bloků. Výchozí je rovna horizontální. Musí být sudá pro YV12 a menší než velikost bloku.

outfile: Jméno souboru pro zápis dat vektorů pohybu. Tato data mohou být použita některým externím programem nebo mohou být dalšími verzemi MVTools pro kódování druhého průchodu, atd.
Vytvářený binární soubor má hlavičku (struktura MVAnalysisData, viz MVInterface.h ve zdrojovém kódu), a sekvenci dat:
číslo snímku, data vektoru (Vx, Vy, SAD) každého bloku, příští platné číslo snímku, data vektoru tohoto snímku, atd.
Výchozí - Prázdný řetězec, nezapisuje soubor.

sharp: metoda interpolace subpixelu pro pel=2,4.
Použijte 0 pro měkkou interpolaci (bilineární), 1 pro bikubickou interpolaci (4 tap Catmull-Rom), 2 pro ostrou interpolaci Wiener (6 tap, podobná Lanczos).
Výchozí je 2.

rfilter: metoda snížení hierarchických úrovní. Použijte 0 pro jednoduchý součet 4 pixelů (průměrování, jako BilinearResize, stará metoda), použijte 1 pro filtr 1/4, 1/2, 1/4 (jako ReduceBy2) pro hladší odhad pohybu.
Výchozí je 1 (od v1.11.0.2).

pelclip: nadvzorkovaný zdrojový klip pro použití namísto vnitřní subpixelové interpolace (pro pel>1).
Pixely v řádcích a sloupcích dělitelné pel (0,2,4,... pro pel=2) musí být původní zdrojové pixely, ostatní pixely musí být interpolovány.
Příklad pro pel=2: LanczosResize(width*2,height*2,src_left=0.25, src_top=0.25). (Nedávná poznámka: je to správné pro jas, ale ne přesně to odpovídá pozicím pixelů barevnosti vnitřní interpolace v MVTools. Přesto vektory a kompenzace pohybu jsou pro obvyklé klipy docela podobné, stejná barevnost by byla s src_left=0.5 pro YUY2 a dodatečně src_top=0.5 pro YV12).
Další užitečný příklad je EEDI2 hranově-namířený resampler.
Pro správné výsledky musíte použít (stejný) pelclip pro celý řtezec funkcí MVTools které používají stejný zdrojový klip (a idx).
Výchozí není definována.

dct: použití bloků DCT (frekvenční spektrum) pro výpočet rozdílu bloků (SAD). Zvláště může zlepšit odhad vektoru pohybu při blikání a stmívání jasu.
0 - obvyklé prostorové (spatial) bloky, nepoužívat DCT;
1 - použít bloky DCT místo prostorových dat (pomalé pro velikost bloku 8x8 a velmi pomalé pro jiné velikosti);
2 - smíchaná prostorová a DCT data; váha závisí na středním rozdílu jasu;
3 - adaptivní přepínání po blocích z prostorového na ekvivalentní-vážený smíšený režim (experimentální, o něco rychlejší).
4 - adaptivní přepínání po blocích z prostorového na smíšený režim s větší váhou DCT (experimentální, o něco rychlejší).
přidané režimy ve v1.9.5.3: (vyžadují sadx264 0-7, používají nejrychlejší SATD funkce, pouze jas!)
5 - SATD místo SAD pro jas
6 - stejné jako 2 jen používají SATD
7 - stejné jako 3 jen používají SATD
8 - stejné jako 4 jen používají SATD
9 - podobné jako 2, používají SATD a vážené rozsahy od SAD jen k ekvivalentním SAD & SATD
10 - podobné jako 3/4,používají SATD váha je na SAD, jen na velké změny jasu
Výchozí = 0.

divide: post-processing vektorů pohybu rozdělením každého bloku na 4 podbloky.
0 - nedělit;
1 - rozdělit bloky a připsat originální vektor všem 4 podblokům;
2 - rozdělit bloky a připsat střední (se 2 sousedními) vektory podblokům;
Výchozí je = 0. Hodnoty velikosti bloku překrytí musí být zvoleny, aby byly přijatelné po vnitřním dělení.

mc: dodatečně zachovat pohybově kompenzované snímky ve vektorovém klipu (použije se v MVDenoise). Výchozí je false (neuchovává se pro šetření paměti) od v1.11.4.

idx: index klipu. Umožňuje vnitřní znovupoužití (sdílení) víceúrovňových dat vypočtených pro snímky klipu několika instancemi filtru (nebo jinými funkcemi) pro rychlejší zpracování a snížení využití paměti. Je obzvlášť užitečný pro pel=2 k zabránění provádění výpočtů interpolace podruhé, při provádění dopředného & zpětného vyhledávání ve stejném klipu. Pokud používáte idx, měli by jste vždy použít kladné hodnoty, a měli by jste použít jen stejnou hodnotu filtrů které pracují ve stejném klipu (jinak by analýza nepracovala správně). Ve výchozím stavu je každé instanci filtru dáno jedinečné záporné číslo (které vytvoří svá vlastní víceúrovňová data).

sadx264: využívá SAD funkcí z kodeku x264 pokud jsou dostupné pro velikost bloku
0 - Autodetekovat CPU a vybrat nejlepší funkce
1 - použít MMX 16x16, 16x8, 8x8, 8x4, 4x4 (8x16, 4x8 použito jen na barevnost - chroma)
2 - použít MMX 16x16, 16x8, 8x8, 8x4 (8x16, použito jen na barevnost - chroma) zarovnáno na 32 bajtové bloky
3 - použít MMX 16x16, 16x8, 8x8, 8x4 (8x16, použito jen na barevnost - chroma) zarovnáno na 64 bajtové bloky, nejlepší pro Pentium M
4 - použít SSE2 16x16, 16x8 (žádné zvláštní zarovnání)
5 - použít SSE2 16x16, 16x8, zarovnáno na 64 bajtové bloky (dobrá volba pro Core)
6 - použít SSE3 16x16, 16x8 (zdá se, že rychleji pracuje jen na Pentium 4E & Core1)
7 - použít SSSES3 16x16, 16x8, zarovnáno na 64 bajtové bloky (dobrá volba pro Core2)
Režimy 8-12 jsou určeny jen pro ladění a testování - použijte místo nich dct >4.
Použití sadx264 > 7 znamená: použít vybraný místo SAD pro jakoukoliv jasové/barevnostní (luma/chroma) SAD kde je to možné!
pro SAD / SATD mix a pouze luma použijte dct
8 - použít SSD mmx, pracuje podobně jako 1
9 - použít SATD mmx, pracuje podobně jako 1
10 - použít SATD SSE2, pracuje podobně jako 2
11 - použít SATD SSSE3, pracuje podobně jako 2
12 - použít SATD SSSE3 s PHADD na 8xY, pracuje podobně jako 2
Výchozí je 0, použijte -1 nebo >=13 pro použití starého algoritmy v1.9.4 SAD a úplnou deaktivaci x264 SAD funkcí.

Zkuste použít funkci MVShow pro kontrolu odhadnutých polí pohybu a vyladění parametrů.

Poznámka: MVAnalyse (pokud Pel=2) detekuje znak videa založeného na polích (po SeparateFields) a automaticky dělá opravu vektorů pohybu v souladu s vertikálním posunem polí s různou paritou. Zkuste použít AssumeFrameBased pokud to nepotřebujete.

MVCompensate

MVCompensate (clip, clip "vectors", bool "scbehavior", int "mode", int "thSAD", bool "fields", clip "pelclip", int "idx")

Provádí plnou kompenzaci pohybu ve snímku. To znamená, že bloky ukázané pomocí vektorů pohybu v referenčním snímku budou posunuty podle vektorů k dosažení jejich umístění v aktuálním snímku.

scbehavior ( výchozí je true ), rozhoduje, který snímek bude zachován při změně scény. Je-li true, snímek je ponechán nezměněný. Jinak je do aktuálního snímku zkopírován referenční snímek.

mode může být buď 0 nebo 1 (výchozí). Mode=0 dříve znamenal použití kompenzace prováděné při vyhledávání vektorů. Nyní je to prováděno v režimu mode=1. Mode=1 znamená, že přepočítává kompenzaci z dat vektorů ( protože můžete chtít použít vektory na jiný klip než ten ve kterém vyhledáváte ). Starý režim mode=2 je nyní vypnutý.

thSAD je prahová hodnota SAD pro bezpečnou (dummy) kompenzaci. Pokud je blok SAD nad thSAD, pak je blok špatný, a my použijeme zdrojový blok místo kompenzovaného bloku. Výchozí je 10000 (prakticky vypnuto).

fields: je-li nastaven na true a pel=2, pak přidáváme vhodná vertikální posunutí (po půlpixelu) polí pro video založené na polích. Zkuste to použít pro odstranění prokládání (ne pro odšumění).
Výchozí je false.

pelclip: nadvzorkovaný zdrojový klip pro použití místo interní subpixelové interpolace (stejné v MVAnalyse).
Výchozí není definováno.

idx pracuje stejným způsobem jako idx v MVAnalyse.

Zpracování překrytých bloků je implementováno jako okenní sumarizace bloků (jako FFT3DFilter, hodnota překrytí do blksize/2) pro snížení blocking artefaktů (kostkatění).

MVDenoise

MVDenoise (clip, clip mvs [,...], bool "Y", bool "U", bool "V", int "thT", int "thSAD", int "thMV")

Provádí časové (temporal) odšumění s kompenzací pohybu z několika klipů vektorů mvs. Referenční snímky jsou pohybově kompenzovány a pak sloučeny s aktuálním snímkem.

První prahová hodnota, thT, rozhoduje zda pixel, který přichází z předchozího nebo následujícího snímku má být zahrnut do procesu výpočtu. Pokud se tento pixel liší více než thT od pixelu v aktuálním snímku, není použit.

Druhá thSAD, rozhoduje zda blok má být změněn nebo ne ( stejný princip jako thSCD1 ). Jestliže se blok změnil, pixely nejsou sloučeny s pixely z předchozího nebo následujícího snímku.

thMV je délka vektoru, nad kterou není blok použit pro odšumění.

Nakonec, Y, U a V říkají na kterých plochách by se mělo odšumovat.

Výchozí : Y, U a V jsou true, thT = 10, thSAD = 200 a thMV=30.

Funkce je zastaralá. Zpracování překrytých bloků je implementováno jako jednoduché sekvenční pokrytí bloky zleva doprava, shora dolů. Funkce používá data kompenzace pohybu uložené v klipech vektorů.

MVMask

MVMask (clip, clip "vectors", float "ml", float "gamma", int "kind", int "Ysc")

Vytváří klip masek z dat vektorů pohybu. Maska je definována daty bloků, ale je interpolovaná, aby zapadla na celou velikost snímku. Maska je vytvořena jak na jasové (luma) tak na barevnostních (chroma) plochách. Hodnoty masky mohou být od 0 (min) do 255 (max).

kind parametr definuje druh masky.

Režim kind=0 vytváří masku pohybu z délek vektorů pohybu. Vytváří lepší masku než MotionMask ( MaskTools ) protože vektory pohybu jsou mnohem víc věrohodné než algoritmus MotionMask. Hodnota masky 0 znamená nikde žádný pohyb ( délka vektorů pohybu je nulová ). Čím větší délka vektoru, tím větší hodnota masky (nasycené do 255), měřítko je definováno pomocí ml.

kind=1 umožní vytvořit masku hodnot SAD (součet absolutních rozdílů) místo délek vektorů. Může to být užitečné k nalezení problémových oblastí se špatným odhadem pohybu. (Je použit vnitřní faktor blocksize*blocksize/4 pro normalizaci měřítka ml.)

kind=2 umožňuje vytvořit okluzní masku (špatné bloky v důsledku roztržení, napětí). V současnosti se používá nějaký normalizovaný součet kladných rozdílů pohybu bloků. Může to být násobeno pomocí měřítka ml.

kind=3 umožňuje vytvořit masku horizontální komponenty vektoru pohybu v jednotkách pel plus 128. Násobené koeficienty se nepoužívají.

kind=4 umožňuje vytvořit masku vertikální komponenty vektoru pohybu v jednotkách pel plus 128. Násobené koeficienty se nepoužívají.

kind=5 - barevná mapa pohybu jako x,y komponent vektorů pohybu zobrazených v U, V barevných plochách (v jednotkách pel plus 128, násobené koeficienty se nepoužívají).

ml definuje měřítko masky pohybu. Když délka vektoru (nebo hodnota jiného typu) je vyšší nebo rovna ml, bude výstupní hodnota nasycena do 255. Menší hodnoty vedou k menším výstupům.

gamma je použito pro definování ukazatele závislosti výstupu na vstupu. gamma = 1.0 znamená lineární závislost, zatímco gamma = 2.0 dává kvadratickou závislost.

A nakonec, Ysc je hodnota vzatá maskou při změně scény

Výchozí jsou: kind = 0, ml = 100, gamma = 1.0, a Ysc = 0.

MVSCDetection

MVSCDetection (clip, clip "vectors", int "Ysc")

Vytváří masku detekce scény z dat vektorů pohybu. Maska je vytvořena jak na jasové (luma) tak i na barevnostních (chroma) plochách. Výstup beze změny scény je 0.

Ysc je hodnota braná maskou při změně scény, výchozí je 255.

MVShow

MVShow (clip, clip "vectors", int "scale", int "sil", int "tol", bool "showsad")

Zobrazuje vektory pohybu.

scale umožňuje zvětšit vektory pohybu, například za účelem zvýšení přesnosti ( když je pel > 1 a scale = 1, neuvidíte odchylky menší než jeden pixel ).

sil umožní vidět různé úrovně analýzy ( když se při vyhledávání vektorů pohybu provádí hierarchická analýza, a může to být zajímavé pro pozorování co se děje ve vyšších úrovních ).

tol je prahová hodnota tolerance. Pokud deformace vyvolaná vektorem pohybu větším než tol, vektor není zobrazen.

Nakonec, showsad umožní zobrazit střední SAD po kompenzaci obrazu.

Výchozí jsou : scale = 1, sil = 0, tol = 20000 a showsad = false ( což zobrazí všechny vektory ).

MVChangeCompensate

MVChangeCompensate (clip vectors, clip)

Umožní měnit kompenzaci uloženou do mvs streamu (streamu vektorů pohybu).

MVIncrease

MVIncrease (clip, clip "vectors", int "horizontal", int "vertical", int "idx")

Umožňuje použít vektory vypočítané pro zmenšenou verzi klipu aby byly použity pro provedení kompenzace v klipu s původní velikostí.

horizontal je horizontální poměr mezi šířkou klipu a šířkou zmenšeného klipu.

vertical je vertikální poměr mezi výškou klipu a výškou zmenšeného klipu.

idx pracuje stejně jako v MVAnalyse

MVDepan

MVDepan (clip, clip "vectors", bool "zoom", bool "rot", float "pixaspect", float "error", bool "info", string "log", float "wrong", float "zerow", int "range")

Dostává vektory pohybu, odhaduje globální pohyb a vkládá data do výstupního snímku ve zvláštním formátu pro plugin DePan (od Fizick).

Globální pohyb uvnitř snímku (panoramování, zoom, rotace) je odhadnut iterativní procedurou, za použití pouze dobrých bloků.

Odmítnuté bloky: 1) poblíž okrajů snímků; 2) s velkým SAD (podle parametru thSCD1 ); 3) s pohybem lišícím se od sousedů nebo globálu.

Parametry zoom a rot přepínají odhad zoom (přiblížení, vzdálení)) a rotaci, pixaspect je protažení pixelu (1.094 pro standardní PAL, 0.911 pro standardní NTSC), error je maximální střední odchylka pohybu.

Vyhodnocený globální pohyb ve snímku se přepne na nulu pro velké chyby pohybu nebo při změně scény (podle parametrů thSCD1, thSCD2 ).

parametr info umožňuje zapsat informace o globálním pohybu pro ladění.

parametr log umožňuje nastavit jméno log souboru ve formátu DeShaker, Depan.

parametr wrong definuje limit pro vypnutí bloků velmi odlišných od sousedních.

parametr zerow definuje váhu nulových vektorů pohybu (pro snížení jejich vlivu).

range - počet předchozích (a také následujících) snímků (polí) v blízkosti žádaného snímku pro odhad jejich pohybu.

Výchozí jsou : zoom = true, rot = true, pixaspect = 1.0, error = 15.0, info = false, wrong=10, zerow=0.05, range=0.

Pro odhad globálního pohybu prokládaného zdroje musíte rozdělit pole (jak pro MVAnalyse tak pro MVDepan).

MVFlow

MVFlow (clip, clip "vectors", float "time", int "mode", bool "fields", clip "pelclip", int "idx")

Provádí kompenzaci pohybu ve snímku ne po blocích (jako MVCompensation), ale po pixelech. Vektor pohybu pro každý pixel je vypočítán bilineární interpolací vektorů pohybu aktuálních a sousedních bloků (v souladu s pozicí pixelu). To znamená, že pixely ukázané vektorem v referenčním snímku budou posunuty (flow - proudí) podle vektorů pro dosažení jejich umístění v aktuálním snímku. Tato flow motion (proudící) kompenzační metoda neprodukuje žádné blokové artefakty, a je dobrá pro odšumění, ale občas může vytvářet velmi zvláštně deformované obrazy :). Pro tuto funkci se důrazně doporučuje skutečný odhad pohybu (true motion). Kompenzace pohybu může být úplná nebo částečná (v mezičase).
Omezení: vektory s komponentami nad 127 budou resetovány na nulovou délku.

time: procento kompenzace pohybu (výchozí=100.0, úplná kompenzace), definuje časový moment mezi referenčním a aktuálním snímkem.

mode může být buď 0 ( výchozí ), nebo 1.
mode=0 - přinést pixely na každé místo cílového snímku. Je to hlavní produkční režim.
mode=1 - posunout pixely z každého místa zdroje (reference). Je to ladící (učební) režim s nějakými prázdnými místy (s nulovou intensitou). Může být použit pro vytvoření masky okluzí.

fields: je-li nastaven na true a pel=2, pak přidáváme vhodná vertikální posunutí (po půlpixelu) polí pro video založené na polích. Zkuste ho použít pro odstranění prokládání (ne pro odšumění).
Výchozí je false.

pelclip: nadvzorkovaný zdrojový klip pro použití místo interní subpixelové interpolace (stejné v MVAnalyse).
Výchozí není definováno.

idx (možná) pracuje stejným způsobem jako idx v MVAnalyse.

MVFlowInter

MVFlowInter (clip, clip "mvbw", clip "mvfw", float "time", float "mL", clip "pelclip", int "idx")

Funkce interpolace pohybu. Není stejná (ale podobná) jako funkce MVInterpolate strších verzí MVTools. Používá zpětných "mvbw" a dopředných "mvfw" vektorů pohybu pro vytvoření obrazu v nějakém mezičase mezi aktuálním a následujícím (podle delta) snímkem. Používá pixelovou (podle metody MVFlow) kompenzaci pohybu z obou snímků. Vnitřní zpětné a dopředné masky okluze (metoda MVMask kind=2) a časově vážené součinitele jsou použity pro vytvoření výstupního obrazu s minimálními artefakty. Pro tuto funkci se důrazně doporučuje skutečný odhad pohybu (true motion).

time: pozice interpolačního času mezi snímky (v procentech, výchozí=50.0, poloviční způsob)

mL: násobící parametr masky. Nižší hodnoty odpovídají silnějším maskám okluzí (jako ve funkci MVMask, použijte ho pro vyladění a odstranění chyb). Výchozí=100.

pelclip: nadvzorkovaný zdrojový klip pro použití místo interní subpixelové interpolace (stejné v MVAnalyse).
Výchozí není definováno.

idx (možná) pracuje stejným způsobem jako idx v MVAnalyse pro zvýšení rychlosti.

MVFlowFps

MVFlowFps (clip, clip "mvbw", clip "mvfw", int "num", int "den", int "mask", float "ml", clip "pelclip", int "idx")

Změní frekvenci snímků (fps) klipu (a počet snímků). Funkce může být použita pro převod frekvence snímků, efekt pomalého pohybu, atd. Používá zpětných "mvbw" a dopředných "mvfw" vektorů pohybu pro vytvoření obrazu v nějakém mezičase mezi snímky. Používá pixelovou kompenzaci pohybu (jako MVFlow, MVFlowInter). Vnitřní zpětné a dopředné masky okluze (metoda MVMask kind=2) a časově vážené součinitele jsou použity pro vytvoření výstupního obrazu s minimálními artefakty. Pro tuto funkci se důrazně doporučuje skutečný odhad pohybu (true motion).

num: čitatel fps výstupního klipu. Výchozí=25.

den: jmenovatel fps (výchozí=1). Výsledná fps = num/den. Především pro dvojnásobnou NTSC fps=2*29.97 použijte num=60000 a den=1001, a pro dvojnásobnou NTSC FILM fps=2*23.976 použijte num=48000 a den=1001. Když num nebo den je rovno 0, pak je pro výstup brána dvojnásobná fps vstupního klipu (od v1.8.1).

mask: režim masky zpracování:
mask=0 jsou jednoduché zpětné a dopředné masky okluze (použité ve verzích do 1.4.x, nejrychlejší);
mask=1 je podobná maska s dodatečným přepínáním na statické nulové vektory v okluzních oblastech (podobné do v1.5.x);
mask=2 je pro použití zvláštních vektorů ze sousedních snímků pro snížení halo efektu u objektů v okluzních oblastech (v1.8, nejpomalejší). Výchozí=2.

ml: parametr měřítka masky. Větší hodnoty odpovídají slabší masce okluze (jako ve funkci MVMask, použijte ho pro vyladění a odstranění chyb). Výchozí=100.

pelclip: nadvzorkovaný zdrojový klip pro použití místo interní subpixelové interpolace (stejné v MVAnalyse).
Výchozí není definováno.

idx (možná) pracuje stejným způsobem jako idx v MVAnalyse pro zvýšení rychlosti.

MVFlowFps2

MVFlowFps2 (clip, clip "mvbw", clip "mvfw", clip "mvbw2", clip "mvfw2", int "num", int "den", int "mask", float "ml", clip "pelclip", int "idx", int "idx2")

Změní frekvenci snímků (fps) klipu (a počet snímků) jako MVFlowFps, ale s trochu lepší kvalitou (a pomalejším zpracováním) s vnějším překrýváním bloků.
(Poznámky: MVFlowFps má nyní efektivnější vnitřní překrývání bloků, a MVFlowFps2 je zastaralý. MVFlowFps2 nepracuje správně s překrýváním v MVAnalyse).
Navíc ke zpětnými "mvbw" a dopřednými "mvfw" vektory pohybu původního zdrojového klipu, funkce MVFlowFps2 používá zpětné "mvbw2" a dopředné "mvfw2" vektory pohybu druhého (upraveného) zdrojového klipu. Druhý klip musí být vytvořen z původního zdrojového klipu oříznutím (t.j. diagonálním posunem) o půl velikosti bloku. Musí to být provedeno příkazem Crop(a,a,-b,-b), kde a=b=4 musí být použito pro blksize=8, a=b=8 pro blksize=16, a a=2, b=6 pro blksize=4 (viz příklad). Okraje bloků budou v různých částech objektů. MVFlowFps2 obrací posun vnitřně a průměruje vektory pohybu z těchto dvou zdrojů pro snížení chyb odhadu pohybu. Funkce používá pixelovou kompenzaci pohybu (jako MVFlow, MVFlowInter). Vnitřní zpětné a dopředné masky okluze (metoda MVMask kind=2) a časově vážené součinitele jsou použity pro vytvoření výstupního obrazu s minimálními artefakty. Pro tuto funkci se důrazně doporučuje skutečný odhad pohybu (true motion).

num: čitatel fps výstupního klipu. Výchozí=25.

den: jmenovatel fps (výchozí=1). Výsledná fps = num/den. Především pro dvojnásobnou NTSC fps=2*29.97 použijte num=60000 a den=1001, a pro dvojnásobnou NTSC FILM fps=2*23.976 použijte num=48000 a den=1001. Když num nebo den je rovno 0, pak je pro výstup brána dvojnásobná fps vstupního klipu (od v1.8).

mask: režim masky zpracování:
mask=0 jsou jednoduché zpětné a dopředné masky okluze (použité ve verzích do 1.4.x, nejrychlejší);
mask=1 je podobná maska s dodatečným přepínáním na statické nulové vektory v okluzních oblastech (podobné do v1.5.x);
mask=2 je pro použití zvláštních vektorů ze sousedních snímků pro snížení halo efektu u objektů v okluzních oblastech (v1.8, nejpomalejší). Výchozí=2.

ml: parametr měřítka masky. Větší hodnoty odpovídají slabší masce okluze (jako ve funkci MVMask, použijte ho pro vyladění a odstranění chyb). Výchozí=100.

pelclip: nadvzorkovaný zdrojový klip pro použití místo interní subpixelové interpolace (stejné v MVAnalyse).
Výchozí není definováno.

idx (možná) pracuje stejným způsobem jako idx v MVAnalyse pro zvýšení rychlosti.

idx2 je index MVAnalyse druhého (posunutého) klipu (nesmí se shodovat s prvním idx).

MVBlockFps

MVBlockFps (clip, clip "mvbw", clip "mvfw", int "num", int "den", int "mode", float "thres", int "idx")

Funkce používá částečnou kompenzaci pohybu založenou na blocích ke změně frekvence snímků (fps) klipu (a počtu snímků). Používá zpětné "mvbw" a dopředné "mvfw" vektory pohybu pro vytvoření interpolovaných obrazů v nějakém mezičase mezi snímky. Pro vytvoření výstupního obrazu se používají některé vnitřní zpětné a dopředné masky a časově vážené součinitele. (Algoritmus je založen na funkci MVInter starých MVTools v1.9.12.) Je to rychlejší než MVFlowFps , ale může vytvářet kostkatění a jiné artefakty. Pro tuto funkci se důrazně doporučuje skutečný odhad pohybu (true motion).

num: čitatel fps výstupního klipu. Výchozí=25.

den: jmenovatel fps (výchozí=1). Výsledná fps = num/den. Především pro dvojnásobnou NTSC fps=2*29.97 použijte num=60000 a den=1001, a pro dvojnásobnou NTSC FILM fps=2*23.976 použijte num=48000 a den=1001. Když num nebo den je rovno 0, pak je pro výstup brána dvojnásobná fps vstupního klipu.

mode: režim zpracování:
0 - průměr dopředné a zpětné částečné kompenzace pohybu (nejrychlejší, výchozí).
1 - statický střed.
2 - dynamický střed.
3 - časově vážená kombinace přenesených dopředných bloků maskovaných posunutými zpětnými a přenesených zpětných maskovaných posunutými dopřednými.
4 - režim 3 smíchaný s jednoduchým statickým časovým průměrem podle masky okluze posunutých bloků.
5 - maska okluze (pro ladění).

thres: prahová hodnota množství okluzí na blok pro binarizaci masky. Výchozí=0, což je vnitřně = blksize*blksizeV/4.

idx (možná) pracuje stejným způsobem jako idx v MVAnalyse pro zvýšení rychlosti.

MVFlowBlur

MVFlowBlur (clip, clip "mvbw", clip "mvfw", float "blur", int "prec", clip "pelclip", int "idx")

Experimentální jednoduchá funkce rozmazání pohybu. Může být použita pro FILM-efekt (simulaci konce otevření závěrky kamery). Používá zpětné "mvbw" a dopředné "mvfw" vektory pohybu pro vytvoření a překrytí mnoha kopií částečně kompenzovaných pixelů v mezičase v nějakém intervalu rozmazání (blurring) kolem aktuálního snímku. Používá pixelovou kompenzaci pohybu (jako MVFlow). Pro tuto funkci se důrazně doporučuje skutečný odhad pohybu (true motion).

blur: časový interval rozmazání (blur) mezi snímky, čas otevření závěrky (v procentech, výchozí=50.0)

prec: přesnost rozmazání v jednotkách pixelů. Maximální krok mezi kompenzovanými rozmazanými pixely. Výchozí =1 (nejpřesnější).

pelclip: nadvzorkovaný zdrojový klip pro použití místo interní subpixelové interpolace (stejné v MVAnalyse).
Výchozí není definováno.

idx (možná) pracuje stejným způsobem jako idx v MVAnalyse pro zvýšení rychlosti.

MVDeGrain1, MVDeGrain2 a MVDegrain3

MVDeGrain1 (clip, clip "mvbw", clip "mvfw", int "thSAD", int "thSADC", int "plane", int "limit", clip "pelclip", int "idx")

MVDeGrain2 (clip, clip "mvbw", clip "mvfw", clip "mvbw2", clip "mvfw2", int "thSAD", int "thSADC", int "plane", int "limit", clip "pelclip", int "idx")

MVDeGrain3 (clip, clip "mvbw", clip "mvfw", clip "mvbw2", clip "mvfw2", clip "mvbw3", clip "mvfw3",int "thSAD", int "thSADC", int "plane", int "limit", clip "pelclip", int "idx")

Provádí časové (temporal) odšumění s kompenzací pohybu. Bloky předchozích a následujících snímků jsou pohybově kompenzovány a pak zprůměrovány s aktuálním snímkem s váženými součinitely závislými na rozdílech bloků od aktuálního (SAD). Funkce podporují režim překrývání bloků.

Zpracování překrývajících se bloků je implementována jako okenní sumarizace bloků (jako FFT3DFilter, hodnoty překrytí do blksize/2) pro snížení artefaktů kostkatění.

MVDeGrain1 má časový (temporal) rádius 1 (používá vektory předchozího mvfw a následujícího mvbw snímku).

MVDeGrain2 má časový (temporal) rádius 2 (používá vektory dvou předchozích mvfw2, mvfw a dvou následujících mvbw,mvbw2 snímků). MVDeGrain3 má časový (temporal) rádius 3 (používá vektory tří předchozích mvfw3, mvfw2, mvfw a tří následujících mvbw, mvbw2, mvbw3 snímků). Je to pomalejší, ale produkuje trochu lepší výsledky (silnější odšumění).

parametr "thSAD" definuje měkkou prahovou hodnotu součtu absolutních rozdílů bloku. Blok se SAD nad prahovou hodnotou thSAD má nulovou váhu při průměrování (odšumění). Blok s nízkou hodnotou SAD má největší váhu. Musíte zadat hodnotu thSAD redukovanou na velikost bloku 8x8. Nízké hodnoty mohou vést k šachovnicovému odšumění, velké hodnoty mohou vést k duchům a artefaktům.
Výchozí thSAD=400.

"thSADC" je prahová hodnota pro plochy barevnosti (chroma).
Výchozí (není-li zadána) : thSADC=thSAD. Pokud je zadána pak thSADCje použito pro barevnost a thSAD je použito pro jas (luma).

parametr plane nastavuje zpracovanou barevnou plochu:
0 - jas, 1 - barevnost U, 2 - barevnost V, 3 - obě barevné roviny, 4 - vše. Výchozí je 4.

limit: maximální změna pixelu (jako plugin DeGrainMedian pro zabránění některým artefaktům). Výchozí je 255 (bez omezení).

pelclip: nadvzorkovaný zdrojový klip pro použití místo interní subpixelové interpolace (stejné v MVAnalyse).
Výchozí není definováno.

idx (možná) pracuje stejným způsobem jako idx v MVAnalyse pro zvýšení rychlosti.

MVRecalculate

MVRecalculate (clip, clip vectors, int "thSAD", int "blksize", int "blksizeV", int "search", int "searchparam", int "lambda", bool "chroma", bool "truemotion", int "pnew", int "overlap", int "overlapV", string "outfile", int "sharp", clip "pelclip", int "dct", int "divide", bool "mc", int "idx", int "sadx264")

Upřesňuje a přepočítává dříve odhadnutá (z MVAnalyse) data vektorů pohybu vectors pro jiný klip clip nebo nastavení nových parametrů (např. menší velikost bloku), po dělení, atd. Tato dvou fázová metoda může být také užitečná pro stabilnější (robustnější) odhad pohybu. Upřesnění se provádí jen na nejjemnější hierarchické úrovni. Interpolované vektory starých bloků jsou použity jako prediktory pro nové vektory, s přepočtem SAD. Jen nové vektory špatné kvality se SAD vyšší než prahová hodnota thSAD budou znovu odhadnuty vyhledáváním. Zadávejte hodnotu thSAD redukovanou (násobenou) na velikost bloku 8x8. Výchozí thSAD=200. Dobré vektory jsou nezměněny, ale jejich SAD bude aktualizováno (přepočítáno).

Další parametry mají stejný význam jako v MVAnalyse (ale můžete použít jiné hodnoty). Použijte jiné hodnoty idx pokud se klip nebo bloky liší.

III) Příklady

Ve všech příkladech předpokládáme, že už je ve skriptu definovaný nějaký zdrojový klip source:

source = AVISource("c:\test.avi") # nebo MPEG2Source, DirectShowSource, nějaký předchozí filtr, atd.

Zobrazení vektorů pohybu ( dopředných ) :

vectors = source.MVAnalyse(isb = false)
source.MVShow(vectors)

Zobrazení zpětných vektorů :

vectors = source.MVAnalyse(isb = true)
source.MVShow(vectors)

Použití MVMask :

vectors = source.MVAnalyse(isb = false)
source.MVMask(vectors)

Odšumnění :

backward_vec2 = source.MVAnalyse(isb = true, lambda = 1000, delta = 2)
backward_vec1 = source.MVAnalyse(isb = true, lambda = 1000, delta = 1)
forward_vec1 = source.MVAnalyse(isb = false, lambda = 1000, delta = 1)
forward_vec2 = source.MVAnalyse(isb = false, lambda = 1000, delta = 2)
source.MVDenoise(backward_vec2,backward_vec1,forward_vec1,forward_vec2,tht=10,thSAD=300)

Deblokování kompenzace uložené v mvs streamu (streamu vektorů pohybu)

vectors = source.MVAnalyse(isb = false, lambda = 1000)
compensation = source.MVCompensate(vectors, mode = 0)
compensation = compensation.Deblock() # použití funkce DeBlock
vectors = vectors.MVChangeCompensate(compensation)

Odšumění s pel = 2, efektivní :

backward_vec2 = source.MVAnalyse(isb = true, lambda = 1000, delta = 2, pel = 2, idx = 1)
backward_vec1 = source.MVAnalyse(isb = true, lambda = 1000, delta = 1, pel = 2, idx = 1)
forward_vec1 = source.MVAnalyse(isb = false, lambda = 1000, delta = 1, pel = 2, idx = 1)
forward_vec2 = source.MVAnalyse(isb = false, lambda = 1000, delta = 2, pel = 2, idx = 1)
source.MVDenoise(backward_vec2,backward_vec1,forward_vec1,forward_vec2,tht=10,thSAD=300)

Použití MVIncrease :

vectors = source.reduceby2().mvanalyse(isb = true)
return source.MVIncrease(vectors, horizontal = 2, vertical = 2)

Použití MVDepan s pluginem Depan pro prokládaný zdroj (příklad funkce DepanStabilize):

source = source.AssumeTFF().SeparateFields() # nastavení správného pořadí polí
vectors = source.MVAnalyse(isb = false)
globalmotion = source.MVDepan(vectors, pixaspect=1.094, thSCD1=400)
DepanStabilize(source, data=globalmotion, cutoff=2.0, mirror=15, pixaspect=1.094)
Weave()

Rozmazání problémových (kostkatých) oblastí kompenzovaných snímků s maskou okluze:

vectors = source.MVAnalyse(isb = false, lambda = 1000)
compensation = source.MVCompensate(vectors) # nebo zde použijte funkci MVFlow
# připravíme rozmazaný snímek s nějakou silnou funkcí rozmazání nebo deblokování:
blurred = compensation.DeBlock(quant=51) # použijeme zde funkci DeBlock
badmask = source.MVMask(vectors, kind = 2, ml=50)
overlay(compensation,blurred,mask=badmask) # nebo použijeme rychlejší funkci MaskedMerge z MaskTools

Nové vytvoření špatných snímků interpolací pomocí MVFlowInter:

backward_vectors = source.MVAnalyse(isb = true, truemotion=true, pel=2, delta=2, idx=1)
forward_vectors = source.MVAnalyse(isb = false, truemotion=true, pel=2, delta=2, idx=1)
inter = source.MVFlowInter(backward_vectors, forward_vectors, time=50, ml=70, idx=1)
# Předpokládejme, že špatné snímky jsou 50 a 60
source.trim(0,49) ++ inter.trim(49,-1) \
 ++ source.trim(51,59) ++ inter.trim(59,-1) ++ source.trim(61,0)

Změna fps pomocí MVFlowFps:

# Předpokládáme progresivní zdroj PAL 25 fps
backward_vec = source.MVAnalyse(isb = true, truemotion=true, pel=2, idx=1)
# použijeme explicitní idx pro rychlejší zpracování
forward_vec = source.MVAnalyse(isb = false, truemotion=true, pel=2, idx=1)
source.MVFlowFps(backward_vec, forward_vec, num=50, den=1, ml=100, idx=1) # získáme 50 fps

Zdvojnásobení fps pomocí MVFlowFps pro nejrychlejší (téměř) k přehrávání v reálném čase:

# Předpokládáme progresivní zdroj PAL 25 fps nebo NTSC Film 23.976
backward_vec = source.MVAnalyse(blksize=16, isb = true, chroma=false, pel=1, searchparam=1, idx=1)
# použijeme explicitní idx pro rychlejší zpracování
forward_vec = source.MVAnalyse(blksize=16, isb = false, chroma=false, pel=1, searchparam=1, idx=1)
source.MVFlowFps(backward_vec, forward_vec, num=2*FramerateNumerator(source), \
   den=FramerateDenominator(source), mask=0, idx=1)

Zdvojnásobení fps pomocí MVFlowFps pro 'nejlepší' výsledky (ale pomalejší zpracování):

# Předpokládáme progresivní zdroj PAL 25 fps nebo NTSC Film 23.976
backward_vec = source.MVAnalyse(overlap=4, isb = true, pel=2, search=3, idx=1)
# použijeme překrývání bloků, přesnost na půl pixelu a Vyčerpávající vyhledávání
forward_vec = source.MVAnalyse(overlap=4, isb = false, pel=2, search=3, idx=1)
source.MVFlowFps(backward_vec, forward_vec, num=2*FramerateNumerator(source), \
   den=FramerateDenominator(source), idx=1)

Změna fps pomocí MVFlowFps2:

# Předpokládáme progresivní zdroj PAL 25 fps. Zkusme ho převést na 50.
backward_vec = source.MVAnalyse(isb = true, truemotion=true, pel=2, idx=1, search=3)
# použijeme explicitní idx pro rychlejší zpracování a použijeme úplné vyhledávání
forward_vec = source.MVAnalyse(isb = false, truemotion=true, pel=2, idx=1, search=3)
cropped = source.crop(4,4,-4,-4) # o polovinu velikosti bloku 8
backward_vec2 = cropped.MVAnalyse(isb = true, truemotion=true, pel=2, idx=2, search=3)
forward_vec2 = cropped.MVAnalyse(isb = false, truemotion=true, pel=2, idx=2, search=3)
source.MVFlowFps2(backward_vec,forward_vec,backward_vec2,forward_vec2,num=50,idx=1,idx2=2)

Generování pěkného rozmazání pohybu pomocí MVFlowBlur:

backward_vectors = source.MVAnalyse(isb = true, truemotion=true)
forward_vectors = source.MVAnalyse(isb = false, truemotion=true)
source.MVFlowBlur(backward_vectors, forward_vectors, blur=15)

Odšumění pomocí nějakého externího filtru pro odstranění šumu (který používá 3 snímky: předchozí, aktuální, následující):

backward_vectors = source.MVAnalyse(isb = true, truemotion=true, delta = 1, idx = 1)
# použijeme explicitní idx pro rychlejší zpracování
forward_vectors = source.MVAnalyse(isb = false, truemotion=true, delta = 1, idx = 1)
forward_compensation = source.MVFlow(forward_vectors, idx=1, thSCD1=500) # nebo použijte MVCompensate
backward_compensation = source.MVFlow(backward_vectors, idx=1, thSCD1=500) # nebo použijte MVCompensate
# vytvoříme postupné 3-snímkové sekvence
interleave(forward_compensation, source, backward_compensation)

DeGrainMedian() # umístěte sem váš oblíbený časový nebo časově-prostorový (temporal nebo spatial-temporal) odšumovač

selectevery(3,1) # vrací jen filtrované centrální (nekompenzované) snímky

Použití předfiltrovaného klipu pro spolehlivější odhad pohybu, ale kompenzaci pohybu nepředfiltrovaného klipu (příklad odšumění)

# Použijte některý odšumovač (rozmazávač) nebo odstraňovač blikání (deflicker) pro předfiltrování
prefiltered = source.DeGrainMedian()
backward_vectors = prefiltered.MVAnalyse(isb = true, truemotion=true, delta = 1, idx = 1)
# použijeme explicitní idx pro rychlejší zpracování
forward_vectors = prefiltered.MVAnalyse(isb = false, truemotion=true, delta = 1, idx = 1)
# použijeme nepředfiltrovaný klip pro kompenzaci pohybu (s jiným idx)
forward_compensation = source.MVFlow(forward_vectors, idx=2) # nebo použijte MVCompensate(mode=1)
backward_compensation = source.MVFlow(backward_vectors, idx=2) # nebo použijte MVCompensate(mode=1)
# vytvoříme postupné 3-snímkové sekvence
interleave(forward_compensation, source, backward_compensation)

DeGrainMedian() # umístěte sem váš oblíbený časový nebo časově-prostorový (temporal nebo spatial-temporal) odšumovač

selectevery(3,1) # vrací jen filtrované centrální (nekompenzované) snímky

Odšumění pomocí MVDegrain2 s překrytými bloky (blksize=8) a subpixelovou přesností:

backward_vec2 = source.MVAnalyse(isb = true, delta = 2, pel = 2, overlap=4, sharp=1, idx = 1)
backward_vec1 = source.MVAnalyse(isb = true, delta = 1, pel = 2, overlap=4, sharp=1, idx = 1)
forward_vec1 = source.MVAnalyse(isb = false, delta = 1, pel = 2, overlap=4, sharp=1, idx = 1)
forward_vec2 = source.MVAnalyse(isb = false, delta = 2, pel = 2, overlap=4, sharp=1, idx = 1)
source.MVDegrain2(backward_vec1,forward_vec1,backward_vec2,forward_vec2,thSAD=400,idx=1)

Odšumění prokládaného zdroje pomocí MVDegrain1 s překrývajícími se bloky (blksize=8) a subpixelovou přesností:

fields=source.AssumeTFF().SeparateFields() # nebo AssumeBFF
backward_vec2 = fields.MVAnalyse(isb = true, delta = 2, pel = 2, overlap=4, sharp=2, idx = 1)
forward_vec2 = fields.MVAnalyse(isb = false, delta = 2, pel = 2, overlap=4, sharp=2, idx = 1)
fields.MVDegrain1(backward_vec2,forward_vec2,thSAD=400,idx=1)
Weave()

Odšumění prokládaného zdroje pomocí funkce MVDegrain2i:

function MVDegrain2i(clip "source", int "overlap", int "dct", int "idx")
{
overlap=default(overlap,0) # hodnota překrytí (0 až 4 pro blksize=8)
dct=default(dct,0) # použijte dct=1 pro klip se slabým blikáním
idx=default(idx,1) # použijte různé idx pro rozdílné zdroje ve stejném skriptu
fields=source.SeparateFields() # rozdělíme pole
backward_vec2 = fields.MVAnalyse(isb = true, delta = 2, pel = 2, overlap=overlap, idx = idx,dct=dct)
forward_vec2 = fields.MVAnalyse(isb = false, delta = 2, pel = 2, overlap=overlap, idx = idx,dct=dct)
backward_vec4 = fields.MVAnalyse(isb = true, delta = 4, pel = 2, overlap=overlap, idx = idx,dct=dct)
forward_vec4 = fields.MVAnalyse(isb = false, delta = 4, pel = 2, overlap=overlap, idx = idx,dct=dct)
fields.MVDegrain2(backward_vec2,forward_vec2,backward_vec4,forward_vec4,thSAD=400,idx=idx)
Weave()
}

source=AVISource("video.avi")
mvdegrain2i(source,4,0,1)

Jak použít externí klip subpixelové interpolace:

# Načtěte plugin Eedi2 (od tritical) s funkcí interpolace se zohledněním směrů obrysů
LoadPlugin("Eedi2.dll")
# vytvoříme ze zdroje nadvzorkovaný klip
ups = source.EEDI2(field=1).LanczosResize(2*width(source), 2*height(source), src_left=0.25)
bv = source.MVAnalyse(isb = true, pel = 2, overlap=4, pelclip=ups, idx = 1)
source.MVCompensate(bv, pelclip=ups, idx=1)

Jak použít s MT filtrem a speciální vícevláknovou verzí AviSynthu:

# Načtěte MT plugin od TSP
LoadPlugin("MT.dll")
avisource("some.avi")
global idx1 = 10  # globální údaje od IanB
MT("""
idx1 = idx1 + 1
# různá vlákna pro horní a spodní polovinu snímku musí mít různé idx (trik od Foxishadis)
backward_vec2 = MVAnalyse(isb = true, delta = 2, pel = 2, overlap=4, sharp=1, idx = idx1)
backward_vec1 = MVAnalyse(isb = true, delta = 1, pel = 2, overlap=4, sharp=1, idx = idx1)
forward_vec1 = MVAnalyse(isb = false, delta = 1, pel = 2, overlap=4, sharp=1, idx = idx1)
forward_vec2 = MVAnalyse(isb = false, delta = 2, pel = 2, overlap=4, sharp=1, idx = idx1)
last.MVDegrain2(backward_vec1,forward_vec1,backward_vec2,forward_vec2,thSAD=400,idx=idx1)
""",2) # dvě vlákna

# Poznámka: Režim SetMTMode(2) vícevláknového AviSynthu je podporován od MVTools v.1.8.4.1 (beta testing)

Stejný příklad se SetMTMode:

SetMTMode(5)
FFmpegSource("some.avi") # avisource nepracuje se SetMTMode na mém stroji - TSchniede

SetMTMode(2)
idx = 1
backward_vec2 = MVAnalyse(isb = true, delta = 2, pel = 2, overlap=4, sharp=1, idx = idx)
backward_vec1 = MVAnalyse(isb = true, delta = 1, pel = 2, overlap=4, sharp=1, idx = idx)
forward_vec1 = MVAnalyse(isb = false, delta = 1, pel = 2, overlap=4, sharp=1, idx = idx)
forward_vec2 = MVAnalyse(isb = false, delta = 2, pel = 2, overlap=4, sharp=1, idx = idx)
last.MVDegrain2(backward_vec1,forward_vec1,backward_vec2,forward_vec2,thSAD=400,idx=idx)

Jak použít předfiltrovaný klip a přepočítat data pohybu původního zdroje (MVFlowFPS příklad)

prefiltered = source.DeGrainMedian() # trocha vyhlazení
backward = prefiltered.MVAnalyse(isb = true, idx = 1, blksize=16)
forward = prefiltered.MVAnalyse(isb = false, idx = 1, blksize=16)
# přepočítání původního zdrojového klipu s jinou velikostí bloku
forward_re = MVRecalculate(source, forward, idx=2, blksize=8, thSAD=100)
backward_re = MVRecalculate(source, backward, idx=2, blksize=8, thSAD=100)
source.MVFlowFps(backward_re, forward_re, num=50, den=1, idx=2)

IV) Odmítnutí záruk

Tento plugin je šířen za podmínek GNU GPL licence, bez jakýchkoli záruk. Viz. 'gpl.txt'.
Dokumentace je šířena pod CreativeCommons BY-SA 3.0 license.

Zvažte prosím provedení nějaké dotace pro podporu.

MVTools používají části kódu z následujících projektů:
Resizer (SimpleResize.cpp) je z Avisynth pluginu SimpleResize od Toma Barryho. http://www.trbarry.com
Fast DCT (fdct_mmx.asm) je z XVID MPEG-4 VIDEO KODEKU. http://www.xvid.org
DCT general transform (viz. fftwlite.h) je z FFTW knihovny (jako DLL výzva). http://www.fftw.org
SATD (pixel-32.asm, pixel.asm) a alternative SADx264 (sad-a.asm, x86inc.asm, x86inc-32.asm, cpu-32.asm) jsou z projektu x264. http://www.videolan.org/developers/x264.html (Loren Merritt, Laurent Aimar, Alex Izvorski et al).

V) Revize

1.11.4.5 (15.11.2008 by Fizick)

1.11.4.4 (15.10.2008 by Fizick)

1.11.4.3 (08.10.2008 by Fizick)

1.11.4.2 (26.09.2008 by Fizick)

1.11.0.1 beta (08.09.2008 by Fizick)

1.10.2.1 (28.08.2008 by Fizick)

1.10.2.0 beta (27.08.2008 by Fizick)

1.10.1.0 not public (22.08.2008 by Fizick)

1.10.0.0 not public (18.08.2008 by Fizick)

1.9.6.x-1.9.7.x series branch (01.08.2008-26.08.2008 by josey_wells)

1.9.5.7 public beta (03.07.2008 by Fizick)

1.9.5.6 (02.07.2008 by TSchniede)

1.9.5.5 (28.06.2008 by TSchniede)

1.9.5.4 (27.06.2008 by TSchniede)

1.9.5.3 (26.06.2008 by TSchniede)

1.9.5.2 (24.06.2008 by TSchniede)

1.9.5.1 public beta (21.06.2008 by Fizick)

1.9.5 (21.06.2008 by TSchniede), based on v.1.9.3

1.9.4.1 beta (12.06.2008 by Fizick, released 21.06.2008)

1.9.4 not public beta (08.06.2008 by Fizick)

1.9.3.1 (05.06.2008 by Fizick)

1.9.3 (20.04.2008 by Fizick)

1.9.2 (29.01.2008, all bugs were found by josey_wells)

1.9.1 beta (15.12.2007 by Fizick)

1.9.0 (04.12.2007 by Fizick)

1.8.6 (02.12.2007 by Fizick)

1.8.5.1 (12.11.2007 by we:)

1.8.4.3 (05.10.2007 by Tsp)

1.8.5 (05.11.2007 by Fizick)

1.8.4.2 (25.10.2007 by Tsp)

1.8.4.1 (23.10.2007 by Tsp)

1.8.4 (22.08.2007 by Fizick)

1.8.3 (17-20.08.2007 by Fizick)

1.8.2 beta (30.07.2007 by Fizick)

1.8.1 beta (28.06.2007 by Fizick)

1.8.0 beta (22.06.2007 by Fizick)

1.7.0 beta (05.06.2007 by Fizick)

1.6.4 (30.05.2007 by Fizick)

1.6.3 (06.05.2007 by Fizick)

1.6.2 (11.11.2006 by Fizick)

1.6.1 beta (25.10.2006 by Fizick)

1.5.8 beta (14.10.2006 by Fizick)

1.5.3 beta (01.10.2006 by Fizick)

1.5.1 beta (05.09.2006 by Fizick)

1.5.0 beta (23.08.2006 by Fizick)

1.4.13 (28.09.2006 by Fizick)

1.4.12 (25.09.2006 by Fizick)

1.4.11 (06.09.2006 by Fizick)

1.4.10 (18.08.2006 by Fizick)

1.4.9 (14.08.2006 by Fizick)

1.4.8 (31.07.2006 by Fizick)

1.4.7 (25.07.2006 by Fizick)

1.4.6 (24.07.2006 by Fizick)

1.4.5 (22.07.2006 by Fizick)

1.4.4 (19.07.2006 by Fizick)

1.4.3 (17.07.2006 by Fizick)

1.4.2 (16.07.2006 by Fizick)

1.4.1 (23.06.2006 by Fizick)

1.4.0 (19.06.2006 by Fizick)

1.3.1 (11.06.2006 by Fizick)

1.3.0 (05.06.2006 by Fizick)

1.2.6 beta (21.05.2006 by Fizick)

1.2.5 (08.05.2006 by Fizick)

1.2.4 (07.04.2006 by Fizick)

1.2.3 (31.03.2006 by Fizick)

1.2.2 beta (01.03.2006 by Fizick)

1.2.1 beta (20.02.2006 by Fizick)

1.2 beta (17.02.2006 by Fizick)

1.1.1 (16.02.2006 by Fizick)

1.1 (non-public build 9.01.2006 by Fizick)

1.0.3 (Released 30.12.2005 by Fizick)

1.0.2 (Released 28.12.2005 by Fizick)

1.0.1 (Released 24.12.2005 by Fizick)

1.0 (Released 29.11.2005 by Fizick)

0.9.13.3 (Released 27.11.2005 by Fizick)

0.9.13.2 (Released 22.11.2005 by Fizick)

0.9.13.1 (Released 21.11.2005 by Fizick)

0.9.13 (Released 20.11.2005 by Fizick)

0.9.12.4 (Released 15.11.2005 by Fizick)

0.9.12.3 (Released 14.11.2005 by Fizick)

0.9.12.2 (Released 13.11.2005 by Fizick)

0.9.12.1 (Released 12.11.2005 by Fizick)

0.9.12 (Released 09.11.2005 by Fizick)

0.9.11.1 (Released 06.11.2005 by Fizick)

0.9.11 (Released 04.11.2005 by Fizick)

0.9.10.1 (Released 01.11.2005 by Fizick)

0.9.10 (Released 31.10.2005 by Fizick)

0.9.9.1 (Released 20.01.2005 by Manao)

0.9.9

0.9.8.5

0.9.8.4

0.9.8.3

0.9.8.2

0.9.8.1

0.9.8

0.9.7

0.9.6.2

0.9.6.1

0.9.5.3

0.9.5.2

0.9.5

0.9.4

0.9.3

0.9.2.1

0.9.2

0.9.1 - 12.05.2004

0.1-0.6 Released 24.01.2004 - 01.04.2004 by Manao

VI) Stáhnout

Stáhnout MVTools v.1.11.4.5

Existuje také nová větev MVTools v2.0 , která je ve vývoji.

Starší MVTools v.0.9.9.1 můžete stáhnout z Manaových stránek

Český překlad:12.3.2009