8 Frame Vertikal Raster Animation zum ausdrucken.

ashyak · February 7, 2009 at 1:56 AM

Hi,

schaut euch das mal an:
http://www.maniacworld.com/animated-optical-illusion.html

Das hab ich jetzt mal in AVIsynth realisiert:

Code

[size=8][noparse]


AVIsource("K:\Moviez\Ong-Bak.avi")


converttoRGB()


breite=2176
streifenbreite=breite/544
killaudio()
TRIM(70000,70000+23) # 24 Frames ausschneiden


vid=selectevery(3,0) # nur jedes 3te Bild verwenden, ergibt effektiv 8 Bilder


#Folgende 3 Zeilen aktivieren um Rastermaske zu erstellen
#a=blankclip(length=1, width=640, height=336, fps=25, pixel_type="RGB32", color=$FFFFFF)
#b=blankclip(length=7, width=640, height=336, fps=25, pixel_type="RGB32", color=$000000)
#vid=a++b
#die Auflösung der beiden blankclip Zeilen sollte identisch mit dem Quellvideo sein!


vid=LanczosResize(vid,breite,breite*height/width)
#framecount()


g0 = zeitraster(vid, 0  ,streifenbreite)
g1 = zeitraster(vid, 8  ,streifenbreite)
g2 = zeitraster(vid, 16 ,streifenbreite)
g3 = zeitraster(vid, 24 ,streifenbreite)
g4 = zeitraster(vid, 32 ,streifenbreite)
g5 = zeitraster(vid, 40 ,streifenbreite)
g6 = zeitraster(vid, 48 ,streifenbreite)
g7 = zeitraster(vid, 56 ,streifenbreite)
g8 = zeitraster(vid, 64 ,streifenbreite)
g9 = zeitraster(vid, 72 ,streifenbreite)
g10 = zeitraster(vid,80 ,streifenbreite)
g11 = zeitraster(vid,88 ,streifenbreite)
g12 = zeitraster(vid,96 ,streifenbreite)
g13 = zeitraster(vid,104,streifenbreite)
g14 = zeitraster(vid,112,streifenbreite)
g15 = zeitraster(vid,120,streifenbreite)
g16 = zeitraster(vid,128,streifenbreite)
g17 = zeitraster(vid,136,streifenbreite)
g18 = zeitraster(vid,144,streifenbreite)
g19 = zeitraster(vid,152,streifenbreite)
g20 = zeitraster(vid,160,streifenbreite)
g21 = zeitraster(vid,168,streifenbreite)
g22 = zeitraster(vid,176,streifenbreite)
g23 = zeitraster(vid,184,streifenbreite)
g24 = zeitraster(vid,192,streifenbreite)
g25 = zeitraster(vid,200,streifenbreite)
g26 = zeitraster(vid,208,streifenbreite)
g27 = zeitraster(vid,216,streifenbreite)
g28 = zeitraster(vid,224,streifenbreite)
g29 = zeitraster(vid,232,streifenbreite)
g30 = zeitraster(vid,240,streifenbreite)
g31 = zeitraster(vid,248,streifenbreite)
g32 = zeitraster(vid,256,streifenbreite)
g33 = zeitraster(vid,264,streifenbreite)
g34 = zeitraster(vid,272,streifenbreite)
g35 = zeitraster(vid,280,streifenbreite)
g36 = zeitraster(vid,288,streifenbreite)
g37 = zeitraster(vid,296,streifenbreite)
g38 = zeitraster(vid,304,streifenbreite)
g39 = zeitraster(vid,312,streifenbreite)
g40 = zeitraster(vid,320,streifenbreite)
g41 = zeitraster(vid,328,streifenbreite)
g42 = zeitraster(vid,336,streifenbreite)
g43 = zeitraster(vid,344,streifenbreite)
g44 = zeitraster(vid,352,streifenbreite)
g45 = zeitraster(vid,360,streifenbreite)
g46 = zeitraster(vid,368,streifenbreite)
g47 = zeitraster(vid,376,streifenbreite)
g48 = zeitraster(vid,384,streifenbreite)
g49 = zeitraster(vid,392,streifenbreite)
g50 = zeitraster(vid,400,streifenbreite)
g51 = zeitraster(vid,408,streifenbreite)
g52 = zeitraster(vid,416,streifenbreite)
g53 = zeitraster(vid,424,streifenbreite)
g54 = zeitraster(vid,432,streifenbreite)
g55 = zeitraster(vid,440,streifenbreite)
g56 = zeitraster(vid,448,streifenbreite)
g57 = zeitraster(vid,456,streifenbreite)
g58 = zeitraster(vid,464,streifenbreite)
g59 = zeitraster(vid,472,streifenbreite)
g60 = zeitraster(vid,480,streifenbreite)
g61 = zeitraster(vid,488,streifenbreite)
g62 = zeitraster(vid,496,streifenbreite)
g63 = zeitraster(vid,504,streifenbreite)
g64 = zeitraster(vid,512,streifenbreite)
g65 = zeitraster(vid,520,streifenbreite)
g66 = zeitraster(vid,528,streifenbreite)
g67 = zeitraster(vid,536,streifenbreite)




return (StackHorizontal(g0,g1,g2,g3,g4,g5,g6,g7,g8,g9,g10,g11,g12,g13,g14,g15,g16,g17,g18,g19,g20,g21,g22,g23,g24,g25,g26,g27,g28,g29,g30,g31,g32,g33,g34,g35,g36,g37,g38,g39,g40,g41,g42,g43,g44,g45,g46,g47,g48,g49,g50,g51,g52,g53,g54,g55,g56,g57,g58,g59,g60,g61,g62,g63,g64,g65,g66,g67))




#folgende function nimmt vertikale, 4 pixel breite Streifen aus jeweils
#8 aufeinanderfolgenden Frames und setzt diese Horizontal aneinander




function zeitraster(clip clip,int n, int sb)
{
a=selectevery(clip,8,0)
b=selectevery(clip,8,1)
c=selectevery(clip,8,2)
d=selectevery(clip,8,3)
e=selectevery(clip,8,4)
f=selectevery(clip,8,5)
g=selectevery(clip,8,6)
h=selectevery(clip,8,7)




aa=crop(a,(n+0)*sb, 0, sb,0)
bb=crop(b,(n+1)*sb, 0, sb,0)
cc=crop(c,(n+2)*sb, 0, sb,0)
dd=crop(d,(n+3)*sb, 0, sb,0)
ee=crop(e,(n+4)*sb, 0, sb,0)
ff=crop(f,(n+5)*sb, 0, sb,0)
gg=crop(g,(n+6)*sb, 0, sb,0)
hh=crop(h,(n+7)*sb, 0, sb,0)


return (StackHorizontal(aa,bb,cc,dd,ee,ff,gg,hh))
}


[/noparse][/SIZE]

Display More

Das ganze funktioniert wunderbar, nur finde ich das Script äusserst hässlich. Deshalb die Frage: wie kann ich hier Schleifen einsetzen, ich verstehe die Syntax nicht :hm:

*edit:
ich habs jetzt ziemlich lange mit Schleifen probiert, ich glaube StackHorizontal unterstützt das aneinander backen innerhalb der Schleife nicht.

ps: ein besserer Titel ist mir nicht eingefallen, ich weiss ehrlich gesagt gar nicht wie diese Animationstechnik heisst, ich weiss nur das das Verfahren uralt ist.

ashyak · February 22, 2009 at 1:47 PM

Soo,

ich hab jetzt die Schleifen/Rekursion ausreichend kapiert und umgesetzt.
Bis zu 4 rekursive Schleifen werden genutzt.

PHP

AVIsource("K:\Moviez\Ong-Bak.avi")


global anzstreifen = 100                                        # Die Anzahl der vertikalen Streifen in der die entsprechenden Frames zeitlich nebeneinander liegen
global anzframes = 6                                            # Die Anzahl der ineinander verschachtelten Frames
sizefaktor = 1                                                      # 1 bedeutet 1 Pixel breite Streifen, 2 dann 2 Pixel breite usw., dies dient der besseren Druckbarkeit.
nxte = 3                                                             # nutze jedes xte Frame. (zeitliche Vergröberung der Animation)


global breite=anzstreifen*anzframes*sizefaktor         # Horizontal Auflösung der Ausgabe
global streifenbreite=breite/(anzstreifen*anzframes)


converttoRGB()
vid=killaudio()


#return vid                 # zum suchen der passenden Stelle
abhier = 69219      # hier den ersten Frame der Animation (Bildfolge) angeben
vid=TRIM(vid,abhier,abhier+anzframes*nxte-1) 


vid=selectevery(vid,nxte,0) # Bilder auslassen
vid=LanczosResize(vid,breite,breite*height(vid)/width(vid))


# Die folgende Zeile aktivieren, falls der Subtitle Text auf weiss angezeigt werden soll.
#vid=blankclip(length=anzframes, width=Width(vid), height=Height(vid), fps=25, pixel_type="RGB32", color=$999999)


#folgende Zeile aktvieren, falls ein String angezeigt werden soll, den String kann man hier auch editieren.
#vid = untertitel(vid, "PREDATOR",0,anzframes)


function untertitel(clip todo, string ntext,int countstart,int countend)
{
Rec_running = "text = MidStr(ntext,countstart+1,1)
todo = subtitle(todo, text, width(todo)/3,0,countstart,countstart,font="+chr(34)+"Arial"+chr(34)+",size=breite/2,text_color=Rand(16777215))"
Rec_end     = "#return maske"
(countstart == countend) ? eval(Rec_end) : eval(Rec_running)
(countstart == countend) ? todo : untertitel(todo, ntext, countstart+1, countend)
}






a=blankclip(length=1, width=Width(vid), height=Height(vid), fps=25, pixel_type="RGB32", color=$FFFFFF)
b=blankclip(length=anzframes-1, width=Width(vid), height=Height(vid), fps=25, pixel_type="RGB32", color=$000000)
maske=a++b
#framecount()


rasterbild = anreihen(vid)
maske = anreihen(maske)


#folgende 3 Zeilen dienen der Ausgabe, info dazu jeweils rechts daneben:
return rasterbild            # das eigentliche Rasterbild
#return maske                  # die Maske um das Rasterbild zu "entschlüsseln"
#return animiere(rasterbild, maske,anzframes)    # Maske auf Rasterbild als Animation.




function animiere(clip rasterbild,clip maske,int anzframes)
{
z = Overlay(rasterbild, maske,mask=invert(maske),x=streifenbreite*0) ++ Overlay(rasterbild, maske,mask=invert(maske),x=streifenbreite*1)
return animrecur(z,rasterbild, maske,2,anzframes)
}




function animrecur(clip todo,clip vid ,clip maske, int countstart, int countend) 
{
Rec_running = "todo = todo ++ Overlay(vid, maske,mask=invert(maske),x=streifenbreite*"+string(countstart)+")"
Rec_end     = "#return maske"
(countstart == countend) ? eval(Rec_end) : eval(Rec_running)
(countstart == countend) ? todo : animrecur(todo, vid, maske, countstart+1, countend)
}


function anreihen(clip vid)
{
y = zeitraster(vid,  0)
rasterbild = recursive(y,vid,1,anzstreifen)
return rasterbild
}


function recursive(clip vid ,clip anfang, int countstart, int countend) 
{
Rec_running = "z = zeitraster(anfang," +string(countstart*anzframes)+")
vid = stackHorizontal(vid, z)"
Rec_end     = "#return anfang"
(countstart == countend) ? eval(Rec_end) : eval(Rec_running)
(countstart == countend) ? vid : recursive(vid, anfang, countstart+1, countend)
}




function zeitraster(clip clip,int n)
{
y = selectevery(clip,anzframes,0)
y = crop(y,(n+0)*streifenbreite, 0, streifenbreite,0)
z = selectevery(clip,anzframes,1)
z = crop(z,(n+1)*streifenbreite, 0, streifenbreite,0)
return (zeitrecur(StackHorizontal(y,z), clip, 2, anzframes, n))
}


function zeitrecur(clip todo,clip vid , int countstart, int countend,int n) 
{
Rec_running = "z = selectevery(vid,anzframes,countstart)
z = crop(z,(n+countstart)*streifenbreite, 0, streifenbreite,0)
todo = StackHorizontal(todo,z)"
Rec_end     = "#return maske"
(countstart == countend) ? eval(Rec_end) : eval(Rec_running)
(countstart == countend) ? todo : zeitrecur(todo, vid, countstart+1, countend, n)
}

Display More

und das kommt dabei heraus:
[Blocked Image: http://img23.imageshack.us/img23/2537/raster.png]

führt man das folgende Raster über das Bild:
[Blocked Image: http://img407.imageshack.us/img407/7756/maske.png]

entsteht die Bewegung:

[Blocked Image: http://img301.imageshack.us/img301/9176/animiert.gif]

die Rastermaske wandert via Overlay über das statische Bild, so kann man sich ein Bild davon machen, wie das ganze ausssieht, wenn man es ausdruckt.
Das Skript ist durch die Schleifen völlig universell geworden, man kann also auch nur 2 Bilder (quasi vertikales Interlacing) nehmen oder wie hier im Beispiel 6, jenseits der 8 sinkt die effektive Auflösung und es wird immer unansehlicher.

Im Skript ist aussderm noch eine Schleife, die einen String Buchstabe für Buchstabe, Frame für Frame gross ins Quellvideo einbindet, das Ergebniss sieht interessant aus.

....cya

Selur · February 22, 2009 at 3:00 PM

Auf jeden Fall nette Sache.

Participate now!