Area of Interest// video

Moving Images

Winter Particles

Posted on by pixelpusher

Happy Holidays! It’s been ages since I posted anything, mostly because I’ve been so busy teaching at UCA Farnham and Openlab Workshops.

Here’s a little something for the holidays. The code is below, and the source image was courtesy of Jan Tik on Flickr.

Continue reading for source code…

Twitter Words Visualization

Posted on by pixelpusher

A visualization of each individual word used in twitter status updates overnight from 6PM GMT on Feb 22 2010 until 10AM GMT on Feb 23. Movement is caused by the list of words growing, as the program sees more individual words. Words used more often are larger and brighter (they grow logarithmically). There were a few points where the feed was lost, and it recounted the same status update over and over (you can tell where because the same words grow larger) but I decided to post this version anyway, because I still think it is interesting in this state. I have collected more data, such as word ordering, and will work on another version. done in Processing – source code is here (you need to add your twitter username and password)

The video above is a bit fuzzy  – here’s a better image:

A visualization of words used in twitter posts over a single night

A visualization of words used in twitter posts over a single night

Tests for a music video for PJE

Posted on by pixelpusher

I’m working on a music video for a song by PJE called The Employee and doing some tests.  The idea is to create the surrealistic daydream of a 1950′s woman on her first day on the assembly line of a dreary, machine-like typist job.  I’m doing all the visuals rendered in fluxus, cut with some excellent archival footage of office films from archive.org.  This one, a 1950′s film called “Office Etiquette” is singular for having some really nice, sweeping, tracking chots mixed with good close-ups, which work well in a music video.  The original has such a cheery attitude about mind-numbing, repetitive busywork that is practically crawling on its knees and begging to be subverted.

I will first cut the video as a straight music video, with close/wide/tracking shots and clean cuts to the beat, then add in the surrealistic, colorful 3D animations done using fluxus and bit by bit break down its sanity.  Look here for more…

messing about with solid 3D geometry

Posted on by pixelpusher

Just a sketch, playing with “extruded shapes” – basically, 3D geometry in a big long cheese log, doped up with some sinusoidal harmonics.

Some code:

(require fluxus-016/shapes
scheme/list)

(clear)

(define l (build-list 20 (lambda (i)
(vector 0 0 (+ 10 (* -1 i))))))

(define w (build-list 20 (lambda (i)
(* 1 (+ 1 (sin (* 3.14156 (/ i 20))))))))

;(define w (build-list 10 (lambda (i) 4)))

(hint-wire)

(define (sinuside circ complexity)
(define (_ c n)
(cond [(< n 1) empty]
[else
(cons (vadd (car c) (vmul (car c)
(* 0.3 (sin (* (* complexity 3.1415) (/ n (length circ)))))))
(_ (cdr c) (- n 1)))
])
)
(_ circ (length circ))
)

(define circle (sinuside (build-circle-points 80 1) 16))

(define pe
(with-state
(rotate (vector 0 0 90))
(build-partial-extrusion circle l 1)))

(recalc-normals 1)

(define (draw-extr e)
(with-primitive e
(partial-extrude
;(* (length l) (+ 0.5 (* 0.25 (+ (sin (time)) 1))))
(length l)
(sinuside (build-circle-points 80 1) (round (* (time) 16)))
l
w
#(0 1 0)
1)
)
)

(define (animator)

(draw-extr pe)
)

(every-frame (animator))

Toad Circle particle system

Posted on by pixelpusher

Video thumbnail. Click to play

Click to Play

Playing with a circular particle system based on a water simulation, done using Fluxus (http://pawfal.org/fluxus). Energy is tranferred between adjacent toads, so after time they start to bounce back and forth chaotically.

Code:

; a simple script that looks like it could be made into a
; water simulation of some kind

(clear)

(require fluxus-016/shapes)

(hint-ignore-depth)

; dimensions of the circles
(define elems 20)
; angle between each element
(define elem-angle (/ 3.14156 elems))

; simulation constants
(define max-dist 10)
(define max-dist-sq (* max-dist max-dist))

(define min-dist 4)
(define min-dist-sq (* min-dist min-dist))

(define max-vel-mag 0.1)

; stops the simulation going out of control
(define max-vel (vmul (vector (cos elem-angle) (sin elem-angle) 0) max-vel-mag))
(define max-vel-sq (vdist-sq max-vel (vector 0 0 0)))
(define trans 0.008)  ; the amount the energy transmitted to
; the neighboring vertex

; feedback velocity per frame
(define feedback 0.1)

; complexity of initial positions (sin peaks, basically)
(define complexity 4)

; make a list of points in a circle
(define circle-points (build-circle-points elems 1))

(define tex (load-texture "/Users/evan/cvs/newflx/fluxus/textures/whitetoady.png"))

(define s (build-particles elems))

(with-primitive s

    (pdata-add "vel" "v")
    (pdata-add "v0" "v")
    (pdata-add "p0" "v")

    (pdata-index-map!
        (lambda (i p)
            (list-ref circle-points i))
        "p")

    ; copy default pos at radius 1
    (pdata-copy "p" "p0")

    ; scale circle radius
    (pdata-index-map!
        (lambda (i p)
;            (vmul p (+ (* (* 0.5 (+ 1 (sin (* 3.4156 (/ i elems)))))
;                (- max-dist min-dist)) min-dist)))
            (vmul p (* (* 0.5 (+ 1 (sin (* complexity (* 3.4156 (/ i elems)))))) max-dist))) 

        "p")

    ; start off the simulation with random point distances
;    (pdata-index-map!
;        (lambda (i p)
;            (vadd p (vmul p (* (* max-dist 0.4) (crndf)) )))
;        "p")

    (pdata-index-map!
        (lambda (i vel p)
            (vmul p (/ max-dist 10)))
        "vel" "p")

    ; store initial velocity
    (pdata-copy "vel" "v0")

    ; start off the simulation with random colours
    (pdata-map!
        (lambda (c)
            (rndvec))
        "c")

    ; start off the simulation with random colours
    (pdata-map!
        (lambda (s)
            (vector 2 2 0.6))
        "s")
    )

(define (simulate n)
    (cond [(< n 0) 0]
        [else

            (let* [(result (pdata-get "vel" n))
                    (p (pdata-get "p" n))
                    (p-sq (vdist-sq p (vector 0 0 0)))]

                (cond [(> p-sq max-dist-sq)
                        ;                        (display "max")(newline)
                        ; we are above "sea level" head down
                        (pdata-set "vel" n (vmul (pdata-ref "vel" n) -0.9))
                        ;                        (pdata-set "vel" n (vmul (pdata-ref "v0" n) -1))
                        (pdata-set "p" n (vmul (pdata-ref "p0" n) max-dist))
                        ]
                    [(< p-sq min-dist-sq)
                        ;                        (display "mIN")(newline)
                        ; we are below "sea level" head up
                        ;                        (pdata-set "vel" n (pdata-ref "v0" n))
                        (pdata-set "vel" n (vmul (pdata-ref "vel" n) -0.9))
                        (pdata-set "p" n (vmul (pdata-ref "p0" n) min-dist))
                        ]
                    [else

                        (let [(pv (* (vdist (pdata-get "vel" (- n 1)) (vector 0 0 0)) trans))
                                (nv (* (vdist (pdata-get "vel" (+ n 1)) (vector 0 0 0)) trans))]

                            ; mix in the surrounding verts to transmit energy around
                            (set! result (vadd result
                                    (vmul result pv)))

                            (set! result (vadd result
                                    (vmul result nv)))

                            ; add the result to the existing velocity

                            (pdata-set "vel" n (vadd (pdata-get "vel" n) (vmul result feedback)))
                            ;(pdata-set "vel" n (vadd (pdata-get "vel" n) result))
                            )
                        ]
                    )

                (let* [
                        (v (pdata-get "vel" n))
                        (v0 (pdata-get "v0" n))
                        (vmax (vmul v0 max-vel-mag))
                        (v-sq (vdist-sq v (vector 0 0 0)))]
                    ; clamp the velocity - this stops the
                    ; simulation going too fast and blowing up
                    (cond [(> v-sq max-vel-sq)
                            ; divide by mag to get sign, mult by max-vel
                            (pdata-set "vel" n (vmul (vmul v (/ 1 (vmag v))) max-vel-mag))
                            ]
                        )
                    )

                )

            (simulate (- n 1))
            ]
        )
    )

(define (render)
    (set! feedback (* 0.4 0.5 (+ 1 (sin (* 0.3 (time))))))
    (with-primitive s
     (rotate (vector 0 0 2))
        (texture tex)
        (simulate (pdata-size))
        (pdata-op "+" "p" "vel")
;        (recalc-normals 1)
        )
    )

(every-frame (render))

Pixelpusher and The Cane Toads at Shunt

Posted on by pixelpusher
The Cane Toads at Shunt 1 Oct 2009

The Cane Toads at Shunt 1 Oct 2009

The Cane Toad Orchestra featuring PixelPusher (or so I like to call it) is playing Shunt next Thursday, Oct 1, 2009, as part of Toplap’s Livecode stage.  That’s right, we’ll have no choice but to make some livecoded music and visuals, and that means sonic and visual anarchy of the most chill quality, kind of like a nice late-season muscat dessert wine, full of bite but thick with sweetness like a long summer day.  (I think that was a triple-simile, and I might have twisted my ankle landing that one.)