8 Frame Vertikal Raster Animation zum ausdrucken.

ashyak

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]

Alles anzeigen

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

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)
}

Alles anzeigen

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

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

entsteht die Bewegung:

[Blockierte Grafik: 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

Auf jeden Fall nette Sache.

Jetzt mitmachen!