Rhea Myers

Tag: Generative Art

  • On Purpose Line

    What seemed to be a problematic edge case in my implementation of the line drawing algorithm from Harold Cohen’s old essay “On Purpose” turned out to need a fundamental rewrite of much of the code (!) and I’m still not done. But I can now get results like this (with green lines for debugging):

    cells.png

    Here’s the main loop, structured to look like the flowchart from the essay:


    (defun draw-line (from to)
    (set-line-drawing-parameters from to)
    (loop named stop
    do  (loop
    initially (set-swing-left-or-right)
    initially (setf panic-count 0)
    do (progn
    (set-length-of-sub-phase)
    (set-rate-of-swing)
    (loop
    do (progn
    (calculate-new-direction-for-line)
    (when (not (within-angular-limits))
    (incf panic-count)
    (when (> panic-count 20)
    (break))
    (setf sub-phase-count 0) ;; Start new phase
    (loop-finish)) ;; This will still evaluate finally
    (correction-for-homing)
    (calculate-position-of-next-point)
    (move-to-next-point)
    (when (reached-destination)
    (return-from stop)))
    until (end-of-sub-phase)
    finally (reverse-swing)))
    until (end-of-phase))))

  • Ben: Line Drawing

    I think that AARON’s basic line drawing algorithm is probably the one described in Harold Cohen’s essay “On Purpose”, or at least a descendant of it.

    I’ve implemented a version of this algorithm to use for Ben. It needs tuning up but here’s an example:

    cells1.png

  • Ben

    After reading the excellent “Paradigms of Artificial Intelligence Programming” by Peter Norvig, I’ve started on a toy re-implementation of Harold Cohen’s AARON. It’s based on AARON circa 1978, so it’s production-system and pixel based, but in Lisp rather than C. After some deliberation I’ve named it Ben, which follows AARON alphabetically, and is smaller.

    Here’s a test of the current version:

    cells.png

    This isn’t a replacement for draw-something, which is inspired by AARON but very different both in terms of how it’s programmed and the images it produces.

  • furtherfield review – Addressable Memory

    furtherfield review – Addressable Memory

    Michael Takeo Magruder is portraying this landscape of digital memory with its own tools, producing portraits of its inhabitants with its own palettes. In Addressable Memory the first draft of history is allegorized as a process of combining and quantizing disparate experience and telemetry. Of mashing-up and composing. The technology and aesthetics of mobile phones, Internet news feeds, video screens, computer image processing and virtual reality are all turned on themselves. At TheSpace4 in Peterborough this show takes up all three rooms. It will be touring the UK throughout 2008.

    My latest review at Furtherfield.

  • draw-something Debugging

    After debugging draw-something quite majorly last year and adding the framework for its future development I thought I had captured all the embarrassing bugs (like drawing things twice…). But I’d missed a bug in my random-point-on-line code that generated points off the end of the line. So draw-something was lovingly generating most of the drawing off the edge of the canvas.

    Working around this has improved the drawings that draw-something creates, here are two I have selected:

    drawing-20080121-233101.png

    drawing-20080121-233324.png

    Now I can start giving draw-something heuristics for deciding what kind of elements should go where, and when.

  • Data Visualization And Corporate Information Culture

    Create Digital Motion » Visualizing Data, and Data as Art

    Regine at We Make Money Not Art has a fantastic overview summarizing a recent workshop of presenting data and numbers visually […]
    What happens when data artists and interaction designers collide with VJs and digital musicians? I'm excited to find out.

    Systems Art – Not Quite The Belaqua Pose – A talk in three voices

    […] a corporatist knowledge culture which has flattened literature, art and the rest of the so-called Humanities into information […]

  • Minara Buffers Working

    MINARA> (setq buf (make-buffer-from-file "./minara.minara"))

    ; in: LAMBDA NIL
    ;     SETQ
    ;
    ; caught WARNING:
    ;   undefined variable: BUF

    ;
    ; caught WARNING:
    ;   This variable is undefined:
    ;     BUF
    ;
    ; compilation unit finished
    ;   caught 2 WARNING conditions
    #
    MINARA> (buffer-to-string buf)
    ";; The minara logotype as a minara file
    ;; Copyright (c) 2004 Rhea Myers
    ;; Generated from an Illustrator EPS file using search & replace...

    (set-colour 0.8 0.8 0.8 0.0)

    (path-begin)
    (move-to 5.0 5.0)
    (line-to 5.0 395)
    (line-to 6.0 395)
    (line-to 6.0 5.0)
    (path-end)

    (path-begin)
    (move-to 5.0 395)
    (line-to 5.0 396)
    (line-to 596.0 396)
    (line-to 596.0 395)
    (path-end)

    etc...

  • Designing Problems are for the Lazy « Zero influence

    It may seem dull, but understanding how a carrot grows is essential to a farmer. Understanding how Photoshop works is not necessary to use it, but to get the best from the system-as-application, knowing more about the under lying code is more important than understanding complementary colours. That's why Rob's Minara is such a smart way to think about the relationship between design and software.
    – Designing Problems are for the Lazy « Zero influence

    Dave talks about The Joneses and design in general and kindly mentions Minara along the way. I should point out that despite a tutor’s once confusing my choice of some horribly coloured paper with a choice of horrible colours I do understand complimentary colours OK. It’s orange I have trouble with. ;-)Minara 2 / Minara 0.1 / Orlando is progressing nicely. Common Lisp is a wonderful language to work with.

  • Minara CL Conversion Complete

    Minara’s codebase is now converted to Common Lisp and I have added the functions and constants to cl-opengl that are needed for polygon rendering.

    Now for debugging…

  • Like That And Metaprogramming

    Like That is a series of moving images made using Processing. It’s intended as a long series of works. So far I’ve been writing each one by hand, which has hampered my rate of progress.

    Inspired by Lisp metaprogramming techniques I’ve realized that the best way of making Like That will be to generate the code for each piece using another program. Rather than messing around with OOP where it isn’t needed, each component of a piece (the shapes, colours and animation) will be defined as a procedure with set parameters that can be combined with a skeleton or scaffold programatically to make a .pde file to build using Processing.

    Each set of different versions of functions will be stored in a separate file then parsed and combined. Like That will be the cross product of the sets of versions of each function. This ties in nicely with the maths pieces I’ve been working on as well.

    I’ll use Lisp for this. It would be nicely recursive if I used Processing instead, but Lisp is my language of choice for most things and this is well within its out-of-the-box capabilities.