Bewegungserkennung

[Kika]

Gibt es eigentlich keine Möglichkeit, eine Variable in Abhängigkeit von erkannter Bewegung zu setzen?
Mit ScriptClip, ConditionalFilter und FrameEvaluate kann ich ja nur Clips zuweisen, außerdem arbeiten die dort vorhandenen Möglichkeiten nicht exakt genug.
Was ich benötigen würde, wäre das Ergebnis eines Framevergleichs als Zahlenwert, um in Abhängigkeit davon unterschiedlich filtern zu können.

[Selur]

Mit ScriptClip, ConditionalFilter und FrameEvaluate kann ich ja nur Clips zuweisen, außerdem arbeiten die dort vorhandenen Möglichkeiten nicht exakt genug.
Clips kann man ja künstlich durch trim's erzeugen, aber was ist Dir z.B. an RGBDifference(clip1, clip2) zu ungenau?

Cu Selur

[Didée]

Mit dem Befehl MotionMask() kann aus zuvor über MVAnalyze() ermittelten Bewegungsvektoren eine "Maske" erstellt werden. Das kann man entweder direkt verwenden (eben als Maske für weitere Operationen), oder man könnte eben diese Maske über die konditionellen Funktionen auswerten: die durchschnittliche "Stärke" der Bewegung in einem Frame über AverageLuma(), oder auch die Änderung der Bewegungsstärke von einem Frame zum nächsten über YDifferenceFromPrevious / YDifferenceToNext.

Könnte man mal probieren. Wie praxistauglich das am Ende ist (d.h. Stabilität bzw. Verlässlichkeit des Ergebnisses), bleibt abzuwarten. Hatte einmal etwas ähnliches auf die Schnelle probiert, aber nichts herausgebracht, was für meine Zwecke brauchbar gewesen wäre.


@Selur: reine Pixel-Differenzen haben zum Zweck der "Bewegungserkennung" noch nie wirklich gut funktioniert. In Szenen mit wenig Kontrast liefert selbst "starke" Bewegung niedrigere Werte als "wenig" Bewegung in Szenen mit starkem Kontrast...

[Kika]

aber was ist Dir z.B. an RGBDifference(clip1, clip2) zu ungenau?
Erstens das, was Didée darüber schreibt und zweitens: Wie kriege ich das Ergebnis in eine Variable?

Sowas wie das hier funktioniert ja anscheinend nicht:

clip1.frameevaluate("flag=YDifferenceToNext()")

Und dann: Wenn flag > x mache dieses, ansonsten jenes.

[scharfis_brain]

wie ich das mache, wenn ich eine variable oder ein flag brauche, dass ich von aussen ins conditional environment reiche:

irgendein clip (32x32 pixel) wird mit einem Lumawert gefüllt, z.B. 128< dann false und 128> dann true.
der clip wird dann im conditional env. per averageluma ausgelesen und dann in eine Variable geschrieben.

[Didée]

Wie kriege ich das Ergebnis in eine Variable?

Sowas wie das hier funktioniert ja anscheinend nicht:

clip1.frameevaluate("flag=YDifferenceToNext()")

Und dann: Wenn flag > x mache dieses, ansonsten jenes.
Doch, genau so funktioniert das. Allerdings muss die Variable "flag" zuvor als global definiert worden sein. Also irgendwo am Scriptanfang z.B. schreiben: "global flag = 0.0".

Wie das mit der Auswertung dann funktioniert ... erst mal die Avisysnth Docu nochmal lesen, und vielleicht auch mal in die einfachen :D Beispielscripte 'reinschauen, wie CDeblend & Co. (MOmonster) oder auch Restore24 :)

(Und, ganz unter uns: wenn ich nicht gerade "aktuell" mit dem konditionellen Kram arbeite, dann muss ich auch immer erst durch nachlesen auffrischen, wie genau das gleich nochmal ging ... ;) )

[Kika]

Doch, genau so funktioniert das. Allerdings muss die Variable "flag" zuvor als global definiert worden sein.

Zumindest auf diese Idee bin ich bereits gekommen. Aber dieses Conditional Environment bzw. Advanced conditional filtering macht mir noch Probleme. Den Rest habe ich ja inzwischen einigermaßen Verstanden - aber das hier ...

Ich denke da linear, das ist wohl der Fehler. Hier mal ein schnell eingehacktes Beispiel:

global flag=4
clip1=Avisource("irgendwas.avi").converttoyv12()
clip1.frameevaluate("flag=YDifferenceToNext()")

clip
subtitle(test,string(flag))

(Blödes Beispiel, ich weiß)

Man würde ja auf die Idee kommen, dass SubTitle den Wert von Flag ins Video schreiben würde - tut's aber nicht, der Wert bleibt auf 4.

[scharfis_brain]

damit sich der Wert ändert, musst Du subtitle() auch ins conditional environment einbauen.

da kommt daher, wie AVIsynth die strkturen durchläuft.
normales script: wird nur einmal geparst und die werte bleiben bis zum ende des videos beibehalten!
conditional environment wird bei jeden frame alles neu geparst (bearbeitet)

[Didée]

(Und wieder mal zu langsam - ich schreib' wohl einfach zu viel)

Der Trick ist, dass die Auswertung von Variablen, hier: "subtitle(test,string(flag))" AUCH über konditionelle Befehle gemacht werden muss. Über "normale" Befehle geht das nicht, weil:

Die ganzen konditionellen Filter arbeiten ja "Frame-für-Frame", d.h. sie werden während der Abarbeitung des Scriptes ausgeführt. (Also auch z.B. die Zuweisung Deiner Variablen "flag".)
Die "normalen" Befehle werden ja nur ein einziges mal abgearbeitet: beim Öffnen des Scriptes, während die interne Prozesskette aufgebaut wird. Zu diesem Zeitpunkt hat "flag" aber nur den manuell zugewiesenen Initial-Wert, und spätere Änderungen interessieren die "normalen" Filter nicht mehr.

Du müsstest in etwa schreiben:

global flag=4
clip1=Avisource("irgendwas.avi").converttoyv12()
clip1.frameevaluate("global flag=YDifferenceToNext()")
ScriptClip(clip1,"subtitle(test,string(flag))")

Oder so ähnlich ... wie gesagt: ohne Nachschauen bin ich da auch sehr rostig.
Eventuell müssen die letzten beiden Zeilen auch *vertauscht* werden: Ketten von konditionellen Befehlen werden, entgegen der sonst üblichen Weise, "bottom to top" abgearbeitet.
Z.B. habe ich solche Ketten in Restore24. Da bestehen diese Ketten aber alle aus Zuweisungen ... Auschnitt:
#----- Conditional function chain - replaces all blends in the bobbed stream :
c5 = scriptclip(dummy, "Evaluate()")
c4 = FrameEvaluate(c5, "global IsBlend_n2 = (btest_n2<btest_n1)&&(btest_n2<btest_n3)")

c3 = FrameEvaluate(c4, "global btest_n3 = btest_n3 * 255.0 / area_n3")
c2 = FrameEvaluate(c3, "global area_n3 = AverageLuma(edgearea_n3)")

c1 = (Eeval<3) ? FrameEvaluate(c4, "global btest_n3 = AverageLuma(edge_n3)")
\ : FrameEvaluate(c2, "global btest_n3 = AverageLuma(edge_n3)")

FrameEvaluate(c1, "ShiftBackVars()")
Man kann sehen, dass hier die Referenzen "von unten nach oben" laufen.

Wie das ohne Zuweisung über Variablen aussieht, einfach mit direktem Hinschreiben von mehreren FrameEvaluate's oder ScriptClip's, dass kann ich jetzt auch nicht sagen. Entweder so-rum, oder anders-rum ... probieren! :)

[Kika]

OK, OK. dann ist eine Sache, die ich gerne erreichen wollte, wirklich nur auf "die harte Tour" möglich.

Über das Conditional Environment bin ich ja schon mal gestolpert, als ich damals das 4:3->16:9-Panning-Script entwickelt habe (zu dem Fr_An übrigens ein nettes Tool entwickelte):

ScriptClip("crop(0,myvar,704,432).Addborders(0,72,0,72)")
ConditionalReader("croppings.txt", "myvar")
Ich konnte es zwar anwenden, bislang aber nicht so genau verstehen.
Wieder was gelernt. ;)

Das Conditional environment bzw. der Umgang damit ist dann wohl sowas wie die Königsklasse der AVISynth-Programmierung.
Aber jetzt habe ich so viel gelernt in den letzten zwei Wochen, jetzt schaffe ich das auch noch - wäre ja gelacht! ;)

Aber eine Sache wäre da noch: Ein älteres Script von mir benutzt ConditionalFilter, um bei wenig Bewegung temporal und bei viel Bewegung spatial zu soften. Um zu testen, ob ich das jetzt wirklich verstanden habe, folgendes: Ist es dann so, dass die jeweilige Filterung nur dann ausgeführt wird, wenn sie von ConditionalFilter angefordert wird?

Also sowas:

clip1=temporal()
clip2=spatial()
conditionalFilter (last,clip1,clip2, "irgendeinfilter")

[Kika]

Oh Mann, ich glaube, ich geb's auf, für Nicht-Programmierer ist das irgendwie zu kompliziert. :(

Aus Frust habe ich das Script wieder gelöscht, aber grob habe ich folgendes gemacht:

Vier globale Variablen definiert.
Eine Funktion geschrieben, die mir einen Durchschnitt der vier Variablen errechnet.
Einen Clip in 4 Einzelclips zerlegt, von denen jeder ein Viertel des Bildes enthält.
Mit Frameevaluate den Wert des Luma-Wechsels (YdifferencetoNext) in den Clips den jeweiligen Variablen zugewiesen.
Mit ScriptClip die AVG-Funktion aufgerufen und durch Anhängen von "true" angezeigt.
Ergebnis: Klappt nicht.

Aus Restore24 und SCD (von Scharfi) weiß ich aber, dass das klappen müsste. Aber was immer ich auch tat, nur die Variable des jeweils letzten Frameevaluates wurde übernommen.

Was ich erreichen wollte, war folgendes:
Die normalen Funktionen zum Erkennen von Bewegung etc. sind ja zu ungenau. Daher wollte ich einen Durchschnitt aus den vier Vierteln bilden und anschließend prüfen, ob in einem der Viertel deutlich mehr Bewegung vorherrscht als in den anderen.

Wahrscheinlich steckt da wieder ein dämlicher Denkfehler drin. Ich hatte den ScriptClip auch hinter den FrameEvaluates stehen (ist mir gerade jetzt erst aufgefallen)

[Kika]

So, ich habe das aus lauter Frust und Wut gelöschte Script halbwegs restauriert und nochmal die AVISynth-Anleitung gelesen sowie diverse Scripte studiert - klappt immer noch nicht.

So sieht das jetzt aus:

LoadPlugin("E:\AviSynth2.5\AVS25Plugins\MaskTools.dll")
LoadPlugin("E:\AviSynth2.5\AVS25Plugins\mt_MaskTools.dll")
LoadPlugin("E:\AviSynth2.5\AVS25Plugins\medianblur.dll")
LoadPlugin("E:\AviSynth2.5\AVS25Plugins\leakkerneldeint.dll")
LoadPlugin("E:\AviSynth2.5\AVS25Plugins\undot.dll")

global fl1=0.0
global fl2=0.0
global fl3=0.0
global fl4=0.0

function getavg(clip cli) {

cli1=cli.crop(0,0,352,280)
cli2=cli.crop(352,0,352,280)
cli3=cli.crop(0,280,352,280)
cli4=cli.crop(352,280,352,280)

cli=scriptclip(cli,"subtitle(string((fl1+fl2+fl3+fl4)/4))")
cli1.FrameEvaluate("fl1=YDifferenceToNext(cli1)")
cli2.FrameEvaluate("fl2=YDifferenceToNext(cli2)")
cli3.FrameEvaluate("fl3=YDifferenceToNext(cli3)")
cli4.FrameEvaluate("fl4=YDifferenceToNext(cli4)")
return(cli)
}

segmentedavisource("d:\capture.avi",true,"RGB24").assumetff()
converttoyv12(interlaced=true)
getavg()


Eigentlich sollte ja dann der Durchschnitt der vier Einzelclips angezeigt werden. Es passiert aber gar nichts. Nichtmalmehr das Ergebnis des vorgestrigen Versuches kriege ich hin. Das eingeblendete Ergebnis ist immer 0 bzw. so, wie es in der ursprünglichen Definition der globalen Variablen fl1 bis fl4 angegeben wurde. Lasse ich diese Definition weg, beschwert sich AVISynth, dass es das fl1 - fl4 im ScriptClip-Befehl nicht kennen würde.
Wenn mir einer sagen könnte, wo da der Denkfehler sitzt, wäre ich überaus dankbar.

[scharfis_brain]

cli vorher mal global machen.

dann

cli=scriptclip(cli,"cli.subtitle(string((fl1+fl2+fl3+fl4)/4))")

[Kika]

Danke, werde ich heute Abend ausprobieren. Ich hatte mich ein wenig (was heisst "ein wenig" ... total! ;) ) an Deinem Script zur Bewegungserkennung orientiert.

Den Unterschied verstehe ich jetzt allerdings nicht. Denn eine Einblendung bekomme ich ja, was fehlt, ist die Übergabe der Werte, die werden immer aus der globalen Definition entnommen und nicht wie geplant aus den FrameEvaluates.

Nachtrag: Das war's auch nicht. :(

[Kika]

So, ich habe es hinbekommen. Das sieht aber völlig anders aus, was die Clip-Zuweisungen betrifft, als alle Beispiele aus der Doku. Drei Varianten habe ich mal erstellt, die alle drei exakt das tun, was ich wollte.

Variante 1
Als durchgehendes Script
global fl1=0.0
global fl2=0.0
global fl3=0.0
global fl4=0.0

segmentedavisource("d:\capture.avi",true,"RGB24").assumetff()
converttoyv12(interlaced=true)

source=last
work=last

work
cli1=crop(0,0,352,280)
cli2=crop(352,0,352,280)
cli3=crop(0,280,352,280)
cli4=crop(352,280,352,280)

source
scriptclip("subtitle(string((fl1+fl2+fl3+fl4)/4))")
frameevaluate("global fl1=YDifferenceToNext(cli1)")
frameevaluate("global fl2=YDifferenceToNext(cli2)")
frameevaluate("global fl3=YDifferenceToNext(cli3)")
frameevaluate("global fl4=YDifferenceToNext(cli4)")


Variante 2:
Als Funktion
global fl1=0.0
global fl2=0.0
global fl3=0.0
global fl4=0.0

function getavg(clip cli)
{
source=cli
work=cli

work
global cli1=crop(0,0,352,280)
global cli2=crop(352,0,352,280)
global cli3=crop(0,280,352,280)
global cli4=crop(352,280,352,280)

source
scriptclip("subtitle(string((fl1+fl2+fl3+fl4)/4))")
frameevaluate("global fl1=YDifferenceToNext(cli1)")
frameevaluate("global fl2=YDifferenceToNext(cli2)")
frameevaluate("global fl3=YDifferenceToNext(cli3)")
frameevaluate("global fl4=YDifferenceToNext(cli4)")
}

segmentedavisource("d:\capture.avi",true,"RGB24").assumetff()
converttoyv12(interlaced=true)
getavg(last)

Variante 3:
Als Funktion, "ältere" Syntax
global fl1=0.0
global fl2=0.0
global fl3=0.0
global fl4=0.0

function getavg(clip cli)
{
global cli1=crop(cli,0,0,352,280)
global cli2=crop(cli,352,0,352,280)
global cli3=crop(cli,0,280,352,280)
global cli4=crop(cli,352,280,352,280)

scriptclip(cli,"subtitle(string((fl1+fl2+fl3+fl4)/4))")
frameevaluate("global fl1=YDifferenceToNext(cli1)")
frameevaluate("global fl2=YDifferenceToNext(cli2)")
frameevaluate("global fl3=YDifferenceToNext(cli3)")
frameevaluate("global fl4=YDifferenceToNext(cli4)")
}

segmentedavisource("d:\capture.avi",true,"RGB24").assumetff()
converttoyv12(interlaced=true)
getavg(last)

Wer jetzt glaubt, es würde mich glücklich machen, dass ich's hinbekommen habe, der irrt. Denn jetzt verstehe ich überhaupt nichts mehr. Grund:
Jeder Versuch, einen Clip anders zuzuweisen, führt zu Fehlermeldungen oder dazu, dass ScriptClip oder Frameevaluate erst gar nicht funktionieren.

Das hier z.B.:
cli1.FrameEvaluate("fl1=YDifferenceToNext(cli1)")
Führt dazu, dass in den Funktions-Varianten cli1 als Clip zurückgegeben wird.
Wenn ich das umgehen will:
cli=scriptclip(cli,"subtitle(string((fl1+fl2+fl3+fl4)/4))")
und einem Return(cli) am Ende der Funktion, werden die Flags (fl1-fl4) wieder nicht gesetzt und bleiben auf 0.
Tja, nun habe ich zwar eine funktionierende Funktion, aber verstehe nicht, wie die Beispiele aus der Doku oder auch beispielsweise scharfis SCD() arbeiten. Da kommen schließlich Dinge wie
f3=f4.frameevaluate("a3=averageluma(msk2)")
am laufenden Band vor.

P.S.: Dass das Script so erstmal keinen Sinn macht, da die so gemittelten Werte auch nichts anderes ergeben, als würde ich YDifferenceToNext() auf den gesamten Clip und nicht die Ausschnitte anwenden, ist mir klar. Aber bevor ich mich an die eigentliche Logik mache, muss ich erst das Conditional Environment wirklich kapieren. Später wird das so abgeändert, dass ich den Durchschnitt berechnen lasse und dann nachschaue, ob in einem der Teilbilder die Bewegung um den Betrag X stärker ist als im Durchschnitt - dann erhält das auch Sinn.

Ach ja, bei allen drei Varianten kann man den folgenden Teil auch weglassen:
global fl1=0.0
global fl2=0.0
global fl3=0.0
global fl4=0.0
Der diente mir nur zu Testzwecken, nötig ist er nicht.
Die drei Beispiele funktionieren sogar auch dann, wenn man in den FrameEvaluates "global" ebenfalls entfernt - aber in der Doku steht, dass die Variablen vom Typ Global sein müssen, also mache ich das auch ...

[Kika]

Hallo,

ich wärme das hier nochmal auf, da ich damit immer noch nicht weiter gekommen bin und ich am kommenden Wochenende an ein paar Scripts arbeiten möchte.
Ansonsten habe ich inzwischen die meisten Syntax-Klippen umschiffen können.

[Didée]

Ach so? Ich dachte, es hätte bereits funktioniert?

Jedenfalls, fällt mir gerade dazu ein: Mit den neuen MaskTools kann man, in manchen Fällen, den ganzen konditionellen Kram auch komplett vermeiden. :)

Wenn Du z.B. was-auch-immer über das konditionelle "AverageLuma()" auswertest, und dann in Abhängigkeit des von AverageLuma zurückgelieferten Ergebnisses entweder dieses oder jenes machen willst, dann bietet sich nämlich auch "mt_Lutf()" aus den MaskTools-v2 an: hier kann man etwa mit

mt_lutf( clip, clip, "avg", Y=3,U=?,V=?)

eine Maske erzeugen, in der alle Pixel genau diesen Wert haben: AverageLuma(clip).
Die Auswertung was dann zu tun ist, kann man ja in einem nachfolgenden Lutxy machen, oder über ein MaskedMerge, oder ... usw.

Mit den beiden Kameraden mt_LutF und mt_LutS kann man noch so allerhand mehr anstellen ... es eröffnen sich ganz neue Möglichkeiten zum Tricksen, oder zur Vereinfachung anderer Sachen. Nur, WAS da alles geht, das ist ... ein Nebel, der sich nur sehr langsam lichtet. ;)

[Kika]

Ach so? Ich dachte, es hätte bereits funktioniert?
Tut es ja auch, Problem ist, dass ich jetzt die anderen Scripte nicht mehr verstehe. Beispielsweise das hier von scharfis_brain, das mir als Vorlage diente:

function scd(clip i, int "factor", int "offset")
{ global fac=default(factor,5)
global off=default(offset,25)

global msk0=i.duplicateframe(0).reduceby2().reduceby2().motionmask(thsd=255,y=3,u=1,v=1)
global msk1=msk0.trim(1,0)
global msk2=msk0.trim(2,0)

global blk=i #blankclip(i)
global wht=i.subtitle("scenechange") #blk.invert()

f1=scriptclip(i,"sc")
f2=f1.frameevaluate("sc=( (a2 > (a1*fac+off)) && (a2 > (a3*fac+off)) ) ? wht : blk")
f3=f2.frameevaluate("a3=averageluma(msk2)")
f4=f3.frameevaluate("a2=averageluma(msk1)")
f4.frameevaluate("a1=averageluma(msk0)")
}
Diese Clip-Zuweisungen kann ich nicht nachvollziehen (f4=f3.frameevaluate... etc.)
Ich denke, wenn ich diesen Part verstanden habe, habe ich es endgültig begriffen. Mit dem Conditional Environment arbeiten kann ich ja dank Deiner und Scharfis Hilfe bereits.
Ansonsten fehlen mir noch ein paar Grundlagen zur Bildung der Kernels bei den MaskTools, das kriege ich aber auch noch hin.

Mit den neuen MaskTools kann man, in manchen Fällen, den ganzen konditionellen Kram auch komplett vermeiden. Das habe ich beim Betrachten einiger neuere Scripts zumindest schon mal bemerkt. So weit bin ich aber noch nicht. Ich bin jetzt erstmals Postings bis zurück nach 2004 bezüglich MaskTools und Conditional Environment durchgegangen, bzw. bin noch dabei, das zu tun.

[Didée]

Tut es ja auch, Problem ist, dass ich jetzt die anderen Scripte nicht mehr verstehe. Beispielsweise das hier von scharfis_brain, das mir als Vorlage diente:
[...]
Diese Clip-Zuweisungen kann ich nicht nachvollziehen (f4=f3.frameevaluate... etc.)
Neinnein, jetzt lass' Dich nicht kirre machen: Du *hast* es bereits verstanden! :)

Anstatt dieses

f1=scriptclip(i,"sc")
f2=f1.frameevaluate("...
f3=f2.frameevaluate("...

zu schreiben, hätte Scharfi die ganzen fX-Variablen weglassen können, und einfach nur

scriptclip(i,"sc")
frameevaluate("...
frameevaluate("...

schreiben können, wäre genau das gleiche.
Diese Art der "Nummerierung" hatte ich so in Restore24 gemacht ... aber in umgekehrter Reihenfolge, um einen visuellen Hinweis darauf zu geben, dass die konditionelle Abarbeitung von unten nach oben erfolgt. (Siehe oben, Post #9)
Scharfi hat halt auch nummeriert, aber (vermutlich) beschlossen dass es besser aussieht, wenn die Zahlen von oben nach unten laufen, anstatt "verkehrt herum". Funktionieren tut's grad genauso ... nur dass eine von beiden Methoden der Notation jetzt anscheinend zur Verwirrung geführt hat. ;)

[Kika]

Neinnein, jetzt lass' Dich nicht kirre machen: Du *hast* es bereits verstanden!

Yippie! :D

Diese Art der "Nummerierung" hatte ich so in Restore24 gemacht ... um einen visuellen Hinweis darauf zu geben, dass die konditionelle Abarbeitung von unten nach oben erfolgt.

Und ich hab' fast schon verzweifelt versucht, nachzuvollziehen, was da mit den Fx-Variablen geschieht und fand nichts ...
Die Bearbeitungsreihenfolge hatte ich ja bereits nach Deiner ersten Erklärung verstanden.
In der Tat war es dann zumindest in meinem Fall so, dass das, was es eigentlich einfacher machen sollte, es (für mich wohlgemerkt) komplizierter gemacht hat.

Dann ist ja jetzt alles klar, vielen Dank.

Wie heißt es so schön in einer Scene in Star Wars? "Bin fast da!". ;)

[schlemihl1277]

Hallo Leute,

Dieser Thread ist recht abstrakt. Daher ist mir noch nicht aufgegangen, worum es beim Thema Bewegungserkennung hier eigentlich geht. Wenn AVIsynth mittlerweile eine Methode bieten würde, Chroma-Keying überflüssig zu machen, wäre das geradezu revolutionär. Aber möglicherweise habe ich das falsch verstanden. Über Hinweise von euch würde ich mich sehr freuen.

best regards,

schlemihl1277

[sade]

Mit "Chroma-Keying" meinst du sowas hier (http://en.wikipedia.org/wiki/Chroma_key) oder? D.h. du möchtest einen anderen Hintergrund zu einem gegeben Vordergrund einfügen, wie z.B. bei Bluescreen-Techniken.

Was hier besprochen wird dient jedoch mehr der Bewegungskompensierung um tempolare Filterung, Deinterlacing, usw effektiver zu machen.
Im Prinzip könnte man es auch für deine Zwecke verwenden, aber es wäre extrem ineffektiv. Bei zuviel Rauschen, Kameraschwenks oder wenn sich der Vordergrund nicht bewegt würdest du sofort falsche Ergebnisse bekommen.