Here is the program for our installation at the Kinetica Art Fair 2012, projected on the back wall:
Area of Interest// art
Winter Particles
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.
Hand-waving-time-slices test
Originally uploaded by da mad pixelist
For an upcoming exhibition (my first solo exhibition) I’ve been working on a series of 5-7 new works, from interactive software to prints to sculpture. These tests are from a live capture of my hand opening and closing in front of a camera attached to the computer, using custom written software (a bit of OpenFrameworks and lots of standard C++) that exports each individual motion into a vector-graphics file (SVG) that I can edit and send to a laser-cutter (in our excellent arts workshops at UCA Farnham) to create a sculpture that solidifies the motion into a physical object.
This test is about 80% size, and about 25% of the total slices (the rest I will add this week). Its using 6mm plywood from the local building shop, and will be 78 unique slices in total when finished, connected together at the bottom via a metal cable.
Exhibition details:
24 May – 29 May – Waving / Drowning
An interactive exhibition by pixelpusher – pixelist.info/
This series of works re-imagines the artist’s hand in a number of different mediums as a series of modern mystical symbols. Their meaning is uncertain, removed from their traditional context: are they waving at us, or flailing in a sea of lost meaning?
Twitter Words Visualization
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
Tests for a music video for PJE
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…
ICE_SNAKE==NOISE
Recorded from a live performance. My first audio-visual (not just visual) work in about 5 years. Created for NOISE==NOISE and The Curiosity Collective’s JohnnyMass on 28 Dec. 2009. Uses Fluxus & SuperCollider.
Smooth Hands
Originally uploaded by da mad pixelist
I’ve been experimenting with extruded shapes, with the end goal of fabricating some interesting ones using a 3D printer at the University I teach at, University for the Creative Arts, Farnham (UK).
So far, it has been a long learning process – first, making extrusions of my hands using Fluxus and a custom-written OpenCV-based image-outline-tracer in C++ (using some OpenFrameworks); then, using Dave’s extrusion functions in fluxus mixed with my live-drawing sketches, coupled with the OBJ-file export, and finally imported into Blender (for some nice ray-tracing).
The trouble is, I can create 3D shapes but hey have no “solidity,” which means their outlines have no thickness. Apparently you can’t 3D print objects and just hope that they are thick enough, or tweak it on the machine, as I’d hoped. No, as with all computers and electronic devices, they only do EXACTLY what you tell them to do, and nothing more or less.
The image here is a reject from Fluxus/Blender, where I created an inner shape by duplicating the original shape and growing it outward along its normals (used for lighting, normals are perpendicular to the surface of the object, meaning they point exactly outwards and are useful for expanding shapes). The problem is that my shape is so complex, I can’t get away with simply growing it. I’m going to need to do some horrible maths, I can feel it…
Still, I really like this image. I’m a big fan of Salvador Dali (don’t laugh) and the infinite blue background and contrasting, surreally-melted hand shape in front lends this image a particularly Dali-esque quality, I think.
messing about with solid 3D geometry
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))
Featured on SketchPatch
I’m proud to announce that the gang at SketchPatch.net were kind enough to make me the featured artist this month!
For those of you who haven’t seen it, SketchPatch is a playground for Processing sketches, where you can create, edit, share, and copy others’ sketches. All sketches on the site are Creative Commons 3.0 attribution licensed, which means you can copy the code and use it as long as you give credit to the original author(s).
Toad Circle particle system
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))
