Programmed Graphics in Computer Art and Animation

Leonardo

Programmed Graphics in Computer Art and AnimationAuthor(s): Mike KingSource: Leonardo, Vol. 28, No. 2 (1995), pp. 113-121Published by: The MIT PressStable URL: http://www.jstor.org/stable/1576132 .

Accessed: 14/06/2014 03:11

Your use of the JSTOR archive indicates your acceptance of the Terms & Conditions of Use, available at .http://www.jstor.org/page/info/about/policies/terms.jsp

.JSTOR is a not-for-profit service that helps scholars, researchers, and students discover, use, and build upon a wide range ofcontent in a trusted digital archive. We use information technology and tools to increase productivity and facilitate new formsof scholarship. For more information about JSTOR, please contact [email protected].

.

The MIT Press and Leonardo are collaborating with JSTOR to digitize, preserve and extend access toLeonardo.

http://www.jstor.org

This content downloaded from 185.2.32.90 on Sat, 14 Jun 2014 03:11:20 AMAll use subject to JSTOR Terms and Conditions

http://www.jstor.org/action/showPublisher?publisherCode=mitpress

http://www.jstor.org/stable/1576132?origin=JSTOR-pdf

http://www.jstor.org/page/info/about/policies/terms.jsp


GENERAL ARTICLE

Programmed Graphics in Computer

Art and Animation

Mike King

VISUAL OUTCOMES IN COMPUTER GRAPHICS

Algorithmic versus Arbitrary In observing the work of artists, designers and animators using computer-graphics systems, I found it useful to invent the terms "arbitrary synthesis" and "algorithmic synthesis." (I in- troduced these terms in previous papers [1,2].) With any computer-graphics system, one synthesizes an image from primitives, which may range from a single pixel to two-dimensional (2D) geometrical shapes to three-dimensional (3D) solid forms. In arbitrary synthesis from primitives, the system has no control over the placement or attribution of each primitive: computer artists follow their own intuitions and reasoning, to which the computer is not party. In algorithmic synthesis from primitives, the artist or designer relinquishes control to some degree by imparting to the computer a set of rules (an algorithm) by which it should incorporate or ma- nipulate successive primitives, which may include a random element. The artist initiates the starting conditions, allowing the computer to take over.

Most computer-generated or computer-manipulated images result from a combination of the arbitrary and algorithmic approaches to synthesis, as defined above, but it is my strong belief that the computer offers something radically

new to artists who explore the algorithmic side of image generation. Beyond the range of imagery not realizable through other methods, there is also the attraction of serendipity: the possibility of an outcome that is unpredictable but at the same time satisfy- ing. The photographer experi- ences this feeling while, for example, watching an image develop in the darkroom, as does the bronze-caster when the mold is broken and the new-born sur-

ABSTRACT

In the early days of computer graphics, artists had to learn programming in order to use the new technology. Today, when such a wide range of software packages runs on affordable hardware, one might ask why artists should continue to learn to program. While this question has been considered for many years, today even expe- rienced artists are looking at the sophistication and affordability of current software and realizing that much of their programming ef- forts could amount to a proverbial reinvention of the wheel. The au- thor considers the continuing rationale for learning to program, taking into account the visual outcomes related to images generated by programming, looking at some practicing artists who use programming in their work and de- scribing his own Windows-based explorations.

face of a sculpture is revealed. Similarly, in computer graphics an image can develop slowly or can become visible after the rendering of an overnight "batch"-even with the prom- ise of ever more powerful systems, it seems there will always be a waiting period that gives rise to a somewhat addictive sense of anticipation. The anticipation arises in part from a certain aspect of programmed graphics (or any non-real-

Mike King (educator), Digital Imaging Group, London Guildhall University, 41-71 Commercial Road, London El 1LA, United Kingdom.

Received 23 August 1993.

Fig. 1. Graham Harwood, The Kiss (1991). This image was generated using custom image-processing routines written by the artist in the C programming language, using an IBM-compatible PC. Harwood is currently rewriting his highly personal image-processing routines for Windows.

LEONARDO, Vol. 28, No. 2, pp. 113121, 1995 ? 1995 ISAST



Table 1. A simple taxonomy of available computer-graphics software.

Paint Bitmapped graphics (paint systems) Draw 2D vector (object-oriented) graphics (draw systems) 3D Modeling and rendering Page Layout Formatting of text and graphics (bitmapped images and vectors) Animation Time-based versions of Paint, Draw or 3D systems

time graphics): the outcome is deterministic, yet it is also, to some degree, unpredictable. It is deterministic because the same starting conditions will produce the same end result (unless we input truly random data, for example, from a Geiger counter), but it is unpredictable in varying degrees due to the complexity of the process.

The concept that a process is deterministic yet unpredictable as a result of its complexity is an important one in the sciences, and especially in computer science. Given the same starting conditions, a computer program will always produce the same end results, and our very lives are increasingly dependent on this fact (think, for example, of the software controlling trains, airplanes and nuclear power stations). Even so-called random-number generators, which are software routines used to vary the outcome of a program, are entirely deterministic and are controlled by their starting parameters. These generators are used in computer art to produce tex- ture or "unpredictable" end results. The end results are only unpredictable because of the complexity of the process, although the degree of unpredictability varies with the level of human experi- ence and the degree to which the computer program or algorithm can be said to be "chaotic." Put simply, a chaotic function or algorithm results in an unpredictability that is a degree greater (in the subjective human sense) than the unpredictability of a non-chaotic one. Its outcome will still be entirely deterministic, however.

One of the very few ways to introduce a genuine random element is to program the computer to take data from the outside world that are beyond the control of the program and that will vary over time. A source of radioactivity that controls a Geiger counter can be used as a source of truly random data, because, as far as I understand, there is nothing within a collection of radioactive atoms that allows one to predict which nucleus will disintegrate at which point in time. Only an overall half-life can be mea- sured for millions of atoms.

Existing Software Most off-the-shelf software graphics packages offer some algorithmic fea- tures, albeit with a certain amount of programming necessary to really exploit their potential. It may therefore be help- ful to look at the types of graphics software available before considering the necessity of programming. In a thesis [3], I outlined a simple taxonomy of computer-graphics software and elabo- rated on its principles in later papers. I list the taxonomy in Table 1, with a few changes to bring it up to date.

The distinctions between the first three categories-paint, draw and 3D- in Table 1 are the most important: software programs can attempt to integrate two or more of these categories, but in practice this is rare. These packages are used in quite different ways and have different visual effects. Page layout is a category outside of the scope of this paper, but it is included for completeness, for it is as well-defined an entity as the previous three. In animation systems, we see examples of time-based paint or 3D packages, but there are no widely available draw or vector animation systems for personal computers (either IBM compatible or Macintosh), the existing ones being high-end systems made for the cartoon industry.

Paint, draw and 3D systems are used for different visual outcomes, though

each may be bent to produce imagery more normally associated with one of the others. Paint systems are useful for applying photographic treatments and paint- erly techniques-generally, to create subtle effects. Draw packages are used to create diagrammatic imagery or techni- cal illustrations; these programs are reso- lution-independent, so output quality tends to be high, but the visual outcomes usually lack the expressivity or subtlety of

paint-system work. Three-dimensional packages are used to simulate "reality" through virtual sculpture (or virtual fab- rication) and virtual photography. The visual results of arbitrary synthesis from primitives are highly dependent on the artist or designer. The algorithmic synthesis effected by these systems is limited to the output of geometrical shapes and variations on inbetweening routines that allow one shape to change into another over time or space or both.

User-Written Software When an artist, designer or animator writes a program in order to generate an image (rather than writing a complete software program), the results do not easily fit into any of the aforementioned software categories. However, the data generated by these programs can apply to one or another of these categories. For example, a piece of code can be used to generate a bitmap file (for use with a paint package), a vector file such as PostScript (for use with a draw package) or 3D data (for use with a 3D modeling package). User-created software will generally be written to exploit an algorithm and, hence, will involve algorithmic synthesis from primitives. It is also possible to write a purely arbitrary "shopping list" of primitives, but in most cases it would be easier to use an existing software pack-

Fig. 2. ESME code fragment: part of a routine used by Stephen Todd and William Latham to generate basic forms (1991).

hhl := horn ribs (20) /* make a horn with 20 ribs */ sphere (0.4) /* out of spheres */ stack (12) twist (400,2) bend (60); /* deformed thus */

hhorn := (horn ribs (20) /* another horn */ sphere (1) /* uses three input forms */ sphere (1.5) /* two sphere of different size */ (csg (hh 1) xrot (90)) /* and the old horn */ stack (40) twist (400) bend (40))

c /* This makes a list of horns */ (horn ribs (40) /* that joins this one */ ellipsoid (1, 0,5, 0,3) /* to the tail of the other. */

stack (20) twist (400,4) bend (40))

114 King, Programmed Graphics in Computer Art



age to do so. (One of the early programming exercises we give students at Lon- don Guildhall University is to use a piece of C programming language code to draw a figure; the result resembles the PostScript output of a draw package used to generate the same drawing.)

With programmed graphics, where algorithmic synthesis from primitives pre- vails, it is easier to classify visual outcomes than with software packages. Many algorithms are based on simple mathematical formulas, often geometric, as geometry is a branch of mathematics with a visual basis. According to Herbert Franke,

If one is engaged, as we are, with an in- ventory of all mathematical branches and with an interest in visualising all forms that come to light, one can ob- tain plenty of forms, shapes and struc- tures never seen before-an expansion of our treasury of forms. Many of these forms have considerable aesthetic charm. According to the usual criteria we cannot call them original works of art. But they can be considered ele- ments available for new creations and can be used to develop artworks [4].

Franke's statement indicates a basis for looking at the visual outcomes of programming: a mathematical taxonomy. I have explored this idea to some extent [5], making a binary distinction between "classical" and "recursive" geometries, the latter having developed only in the last century. The full importance of these applications has only become visible through the use of the computer in this century. The mathematical taxonomy I propose is shown in Table 2.

IMAGE PROCESSING

Image processing differs from the previously explored methods of algorithmic synthesis from primitives in that it does not involve the continued addition of

A

U U

Fig. 3. Interacting with Mutator: computer screen showing families of evolved form and part of the Mutator menu (1991).

primitives under algorithmic control, but rather the recomputing of pixel values in an existing bitmap (for example, a scanned photograph). Image processing involves such a wide range of techniques that one can effectively subdivide them into the following categories:

* point processes: each dot or pixel is processed without regard to its neighbors

* area processes: neighboring pixels are taken into account

* frame processes: two or more images are combined

* geometric processes: pixels are moved from their original positions.

These categories are taken from Image Processing in C by Craig Lindley [6]. Adobe Photoshop, a typical image-processing program for the Macintosh or

Table 2.

Classical Geometries * geometrical primitives, such as circles and rectangles * mathematical functions, such as roots, squares, exponential curves, parametric

curves and surfaces * patterns, including nets, bands and tessellations

Recursive Geometries * iterative functions (recurrence relations) * random numbers (usually based on iterative functions) * fractals and graftals * particle systems * growth models * linear and array grammars * Markov chains

Windows environment, offers a wide range of these processes, covering all four categories. The geometries involved in the last category are often simple displacements of an image based on waves or spirals, but in principle any of the algorithms in the taxonomy outlined in Table 2 could be used. Graham Harwood [7], whose work is discussed below, has extended the point process with the replacement of pixels by line segments, whose attributes depend on the intensity of the pixel (Fig. 1).

ARTISTS USING PROGRAMMING One could argue that the first computer artists were people like Herbert Franke and Ben Laposky, whose experimenta- tion with images generated with oscillo- scopes began as early as 1950. Laposky referred to these early experiments as "oscillons" or "electronic abstractions" [8]; they were initially generated with analog devices. These early techniques readily translated into digital computer graphics, and have helped define the visual language of computer imagery ever since. Similar mathematical techniques were exploited by John Whitney, Sr., in his pioneering animations of the 1960s [9]. Whereas Whitney's animations were abstract and based on the "classical" geometries described earlier, another pio- neer, David Em, worked with 3D imagery based originally on programs written

King, Programmed Graphics ini Computer Art 115

I W

t

:'k 91. 4

.41 :. 10. 1.



Fig. 4. William Latham, Mutation Y1 Raytraced on the Plane of Infinity, 1992. This image is typical of work that Latham has exhibited internationally in the form of large photographic prints. The computer-generated image is made into a slide using a special device called a film recorder, and a conventional photographic print is then made from the slide.

Fig. 5. Richard Wright, image from the computer animation Corpus, 1992. The software for this work, written by the artist and his collaborator Jason White, involves a renderer, wave- model generator and compositing software.

to simulate planetary bodies [10]. By the time Em began experimenting with computer graphics in 1975, simple paint systems had become available; his work is a mixture of paint-system and programmed techniques. Much of the programming was done by James Blinn at the Jet Propulsion Laboratory (JPL) in Pasadena, California, and Em was able to use and modify pioneering codes that give rich textures to 3D surfaces.

Whitney and Em are examples of a tradition of artists working in large institutions (IBM and JPL, respectively) whose aims and environment are far re- moved from those of painters. William Latham, whose work I will discuss in more detail below, is a printmaker and sculptor who is a modern exponent of that tradition at IBM [11]. There are other examples of artists collaborating with programmers: John Pearson em- ployed undergraduate programmers to produce a series of combinations of arc segments used in his paintings [12], and Harold Cohen, discussed below, works with artificial-intelligence experts [13]. Other artists have worked largely outside of institutions and without programming help, using their own machines and skills instead: Mark Wilson [14] and Edward Zajek [15] are examples.

The first edition of Franke's Computer Graphics-Computer Art [ 16] provides an introduction to the work of programming pioneers and also presents an early discussion of the aesthetics of computer art. In Digital Visions [17], a more current publication that includes imagery from software packages, Cynthia Goodman provides good nontechnical coverage of early computer artists, showing that the bulk of their work was real- ized through programming only because nothing else was available until the introduction of early paint and 3D packages.

Latham, as mentioned above, suc- ceeded pioneers Whitney, Em and Cohen by collaborating with a large in- stitution: IBM. Latham is presently a full-time research fellow at the U.K. Sci- entific Centre in Winchester, United Kingdom, and collaborates closely with Stephen Todd and a team of programmers and researchers. He has developed a unique 3D computer-graphics system that allows him to mutate 3D forms and animate them. At the heart of the creative process is a system component called "Mutator," which allows the generation of basic forms, their evolution through random mutations of gene




"vectors" and their breeding and selection, giving Latham the opportunity to act as "creative gardener."

The 3D models with which Latham originally works are created from a combination of fairly traditional 3D computer-graphics primitives (cube, sphere, cone and so on), using Boolean modeling controlled through a scripting language called Extensible Solid Modeling Editor (ESME). The ESME programs are created with a text editor and give algorithmic control over the placement of primitives, including the use of a programming technique called recursion, which in this context corresponds to the recursive geometries mentioned earlier. Figure 2 illustrates an ESME code fragment. Mutator has now taken over this "low-level" text-driven algorithmic control through the use of the metaphors of evolution and breeding, as in Fig. 3, which shows evolving forms and the main Mutator menu. This is an interest- ing example of algorithmic synthesis from primitives controlled at one level by writing code and at another level by an interactive user interface. Figure 4 shows a "still" image, a final piece generated by the system, chosen by Latham for exhibition in the form of a large photographic print. The illustrations are excerpted from Evolutionary Art and

Computers, by Todd and Latham [18], which describes the systems in detail. Latham's use of evolutionary algorithms leads to the question: what takes the place of natural selection? His answer is not in the form of a "survival of the fit- test" algorithm, but instead is found in his approach as flower gardener-he simply selects according to his own visual sensibilities.

Karl Sims, a computer artist with a background in science, uses an approach similar to Latham's in his Panspermia series, creating scenes with 3D plants controlled by genetic parameters [19]. The plants are crossbred using a "survival of the prettiest" approach to select the final set of parameters. The results are quite different from Latham's work. While applying similar selection criteria, Sims creates a kind of realism involving plausible vegetation. Sims is currently artist-in-residence at Thinking Machines Corporation, which supplies funding for the computing power necessary in his work.

Harold Cohen, a British artist who had attained success as a painter by the mid-1960s, wrote his first computer program in Fortran (formula translation) in 1968, at the age of 40. From this pro-

Fig. 6. Mike King, Rings of Custody, 1991. This image involved the writing of approximately 60,000 lines of code, constituting a range of software packages, and the modification of another 20,000 lines of code (originally written by Richard Wright), which make up the RayScan ray-tracer used in rendering the image. The image involves the arbitrary composition of spheres, with algorithmic placement of the spheres along circular and grid trajecto- ries. The background, created using about 200 lines of code, was generated from a one-off piece of code that manipulates a bitmap in perspective.

gram evolved "Aaron," an artificial-intelligence (AI) program that became ca- pable of generating figurative drawings by the mid-1980s. Cohen's work illustrates one of the major attractions of learning to program: one can achieve something unique, pioneering and important. This is meant quite seriously, although his work is often overlooked, de- spite one-man (or should it be one-man-and-one-computer?) shows around the world, including one at the Tate Gallery in London, England [20].

Cohen has used programming to incorporate rules of painting or composition derived from an analysis of his own and others' work, including children's drawings. His imagery is not based on mathematics, geometry or algorithms in the same sense that these form the basis of the previously described work. Rather, it is based on decisions or, at a more basic level, on "if-then-else" statements.

Cohen's work does, however, fit into the category of algorithmic synthesis from primitives, although the algorithms are not so much derived from mathematics or geometry as from what Cohen terms cognitive primitives. In Aaron's Code [21] Pamela McCorduck cites Cohen as saying, "The program [Aaron] has always been structured in terms of cognitive behaviour, not in

terms of form."(This is in contrast to Latham's work, which is based on the "evolution of form.")

Cognitive primitives generated in early versions of Aaron are often related to the subdivisions of a surface. In Cohen's work, this relation is clearly apparent in a series of entirely abstract works entitled Three Behaviours for Partitioning Space; much later, Cohen uses Aaron in a much different way to create representations of rocks, plants and people in the explicitly figurative Eden series. Cohen says of the direction of his work:

Aaron ... does not do naturalistic pas- tel drawings, not because it would be difficult, but because it would be inap- propriate. But I would also not have it in mind to draw those interminable geometrical figures popularly identi- fied by now as "computer art" [22].

According to McCorduck, Aaron was originally written in the C language, the environment in which it remained until 1990, when it was translated into or re- written in LISP (LISt Processing), a programming language more commonly associated with artificial intelligence. Cohen has benefitted from collaboration with Digital Equipment Corporation (DEC), which loaned him DEC VAX machines for his shows and eventually gave him a DEC machine of his own. Consid-

King, Programmed Graphics in Computer Art 117



erable computing power is needed for Cohen's work (as for Latham's and Sims's work). In 1979, his machine oper- ated with only 64 K of Random-Access Memory (RAM), while his present machine runs on 34 MB, an increase of a factor of about 500-which probably re- flects the overall increase in power available to him over the period.

Harwood, a colleague of mine at Lon- don Guildhall University, founded Working Press and also originated many counter-culture publications in the United Kingdom [23]. He began to use computers as a direct result of his use of photocopiers and in order to achieve some of the aims set out in the "Festival of Plagiarism" [24]. At the time (1987), there was little available software compatible with affordable computers that could perform the kind of image ma- nipulation in which Harwood was interested, so he wrote his own software in the C language, using an IBM-PC compatible. Although he says now that he could probably continue his work without having to write his own code, he still intends to continue programming for specialized image-processing effects, in particular effects that produce a sense of appropriation, corruption and degrada- tion, as shown in Fig. 1.

Harwood rarely uses mathematical formulas or geometry as starting points, preferring instead to start with a desired visual effect and then work backwards to uncover the required code using common sense. He tends not to incorporate into his work the algorithms developed by computer-graphics researchers (often printed in publications such as the SIGGRAPH conference proceedings), yet he still likes to feel part of a programming community, partly to counter

the traditional "precious" image of art and artist.

Harwood is currently considering the programming of plug-ins (small pieces of code that can be added to or taken away from a main software package) for existing packages such as Photoshop. He is also looking into writing interactive works that would allow users to make their own ways through his stories. He prefers print media such as the broad- sheet, booklet or magazine, which he chooses on the basis that there are currently not enough potential readers equipped with the multimedia technology necessary to access interactive works. As that changes, however, he envisages distributing his work on CD-ROM.

Richard Wright, also from London Guildhall University, is known for his computer animations Superanimism [25] and Corpus (Fig. 5), the latter of which was jointly produced at New York Insti- tute of Technology (NYIT) and London Guildhall University. Wright is also known for his writings on computers in culture. Wright was a research fellow at IBM-U.K. (before Latham took the post), where he developed his focus on computer graphics as a visualization tool in science [26]. He wrote a ray-tracer (a 3D computer-graphics program for real- istic rendering) as well as other software programs that he has used in his own animations. I have also used Wright's software in the renderer of my Sculptor images [27].

Originally, Wright became interested in computer-graphics programming not only because it offered an alternative to manual methods of production, but also because of the new imagery available through mathematical techniques. While much of the software he has writ-

Fig. 7. Creating a Windows custom dialogue box using the Borland Re- source Editor. Note the use of a grid to lay out the panel, and the various tools available for creating and editing custom controls.

ten is now commercially available, he still finds many techniques realizable only through programming. Wright also asserts that his familiarity with computer-graphics programming journals enables the implementation of leading- edge techniques that can take many years to reach commercially available packages. Wright also believes that programming allows artists to impose their own "marks" in a more consistent way than is possible with commercial packages. (I have also seen this advantage of programming while working on the Sculptor series; the style imposed by commercial 3D systems contradicted my own individual style.)

Wright has received a grant from the Arts Council of Great Britain to pursue his current project, Heliocentrum, which involves use of an advanced liquids visualization technique. The fluid dynamics software Wright uses was adapted from a SIGGRAPH paper by Cass and Miller [28].

WRITING PROGRAMS How have artists' rationales for programming changed over the last 40 years-particularly in recent years, which have brought the availability of good art software and affordable hardware? What other factors are there?

A feature of early computer graphics was its vector orientation: output devices such as screens and plotters drew lines, which algorithms made use of. As vector technology has been replaced with raster technology and lines have been replaced by grids of dots, the capacity for continu- ous-tone imagery has evolved-and so have the appropriate software packages. Raster graphics have probably compli- cated the writing of software. The first reason for this is because there are few standards concerning graphics displays and color output. (In the old days one had lines and that was it-if one wanted to, one could change the pen!) The second problem is that the potentials of raster graphics tend to lead to more ambi- tious projects, which lead to the need for more powerful equipment (as is apparent in the work of Latham, Cohen and Sims). Paradoxically, powerful computers are often incompatible with commercial art software programs: few artists and designers are likely to own top-end Unix boxes or supercomputers, so there is a very small market for good art and de-

sign packages for this type of hardware. Historically, most programming by

computer artists has involved the writing




of small stand-alone programs to produce certain visual outcomes (Cohen's Aaron, a single program that grew over a period of nearly 25 years, is a rare ex- ception). Early programmers used For- tran, Algol or machine languages to interface with plotters. Today the preferred programming languages are C and Basic, which include compilers and interpreters that are readily compatible with Macintoshes, IBM-PCs and Unix platforms. While libraries of basic graphics commands are included within the compilers, there are no common usage standards: the chances of finding a com- mand that will draw a filled rectangle in the same way on three types of system are small.

With the increased availability of commercial software packages for the Macintosh and IBM-PC, each offering a huge functionality, some of the reasons for writing programs have gone. Some of the reasons are still with us, however: many software developers are aware that their package, however huge it grows, will never satisfy the needs of all their customers. Hence the introduction of software with programming "hooks," which allow users to write specialized bits of code.

One such program is AutoDesk's Ani Pro, a 2D animation package for IBM- PCs, with an available color palette of eight bits (256 colors). Its programming interface consists of a C-language inter- preter (called Poco), which is accessible from a pull-down menu. Programmers can also access a well-documented library of functions that represent Ani Pro's interface, drawing tools, inks and time-based commands. Poco seems best suited to interactive programming, as its execution of code is approximately 10 times slower than that of compiled code; however, the code can be compiled to run faster with custom compilers.

Another program with hooks is 3D Stu- dio, a professional-level 3D animation package also produced by AutoDesk. This application uses C-language plug-ins called external processes, which, unlike Ani Pro's, are externally written and compiled routines generated by a protected- mode compiler (a compiling program that produces code that makes use of the larger memories of more powerful PCs). 3D Studio's plug-ins are divided into four types: (1) image processing, (2) procedural modeling (e.g. waves and spirals), (3) procedural animation (e.g. particle systems) and (4) procedural textures.

These plug-ins allow for the incorpora- tion of algorithmic synthesis of primitives

|'.i:_..." ~I Borland C++- [cAwcprogsVnathspiclmathspic.c] IlH

"g File Edit Search Run Compile Project Browse Options Window lelp || .-..-.-:. =_: ....... . - , - - ...-

} /* Chaos */

vo Dile Examnples filter system

Entersteps Enterfrequency

i~ i l11300 1 IR Fii; ;10 Enter sub stratum freq No of cycles for white i

first time = false;

Get 4 reals ("Enter steps", response l, "Enter frequency", response 3, "Enter sub stratumi freq", response 6, "No of cycles for white", response 5);

step = atoi (response_l) ; freq = atof(response_3); sub_freq = atof(response_6); cycle_min = atof(response _5); use_squares = TRUE; /* response_5[0] == 'y'; */

Fig. 8. Use of the custom dialogue box to enter parameters for a mathematically controlled pattern. The values are "remembered" so that one can run the program, look at the result, run it again and modify one or more parameters without writing them down. This allows for rapid exploration of "parameter space."

into an interactive package, which is ideal for artists and programmers wish- ing to expand upon existing options.

The computer artist can begin a project by writing specialized pieces of code, eventually developing the pieces of code into a package. While some artists later distribute the resulting packages as shareware (FRACTINT, a program for generating fractal images, is a good example) or as commercial ven- tures, others might not wish to allow anyone else to access their software, preferring instead to protect the originality of their work. Some artists add interactive user interfaces to their programmed graphics; others limit interaction to specification of parameters-e.g. coor- dinates-that would be tedious to type in as numbers.

On older systems, one had to write all the code for any interaction. Each software developer did this in a different way, resulting in a wide range of user interface styles on the same machine. A large part of the development effort for a software package would go into the user interface, with the minor advantage, however, that one could build the interface to suit one's own perceptions of its design.

Graphical user interfaces (GUIs) such as Windows for the IBM-PC, the various Macintosh systems, and Unix-based WIMPS (Windows, Icons, Mouse and Pull-down menuS) provide developers

with a standard way to build interfaces, as well as libraries of code to incorporate into their software programs. There are, however, disadvantages to programming on these systems. First, programmers must use the interface routines provided. Second, it is an immense chal- lenge to learn all of the 1,000 or so library functions included in either the Windows or Macintosh platforms. Fur- thermore, there is a whole new philoso- phy of programming inherent in these systems, summed up by the phrase "don't call us, we'll call you." This means that the artist must take into account the possibility that users may want to access other parts of the total system, and not just the artist's program. One's program must be ready to accept messages from the mouse and keyboard that belong to other programs and pass them on. In practice, this means that one's own program has to wait to receive messages that do concern it, and that it must allow the processor to do other things with messages that don't.

In my own work as a computer artist and educator, I have written about 100,000 lines of code, most of it for the following packages: PolyPaint (an 8-bit broadcast paint system), the Integrated Computer Art System (ICAS), Smart 3D (a simple 3D modeler) and Sculptor (a 3D system based on spheres as the sole primitive). For more than 5 years, my students and I have used the PolyPaint




system at London Guildhall University; I was able to take advantage of locally available user feedback in creating this system. I have also used one-off pieces of code (pieces of code written for a spe- cific, immediate purpose, such as generating the background of a particular image) in the backgrounds of some ray-traced Sculptor pieces (Fig. 6).

How does the range of affordable new software affect my own rationale for programming software packages? Admit- tedly, I was motivated to program by my interest in interface design research. More inspiring, however, was my desire to write programs from a personal perspective and create functions not available in commercial packages. For example, no other program places as much importance on pattern-making as ICAS does.

In order to bring together a select range of small math-based programs and also to learn how to program in Win- dows, I built a Windows framework called

Fig. 9. Mike King, The Car Crash of G.I.

, ~ ~~* ~ Gurdjieff, 1993. Each

: ..... image was gener- *aci * I _nated using routines

that simulate in-

verse-square law attractions; the images were later modified

1!i~ ~ ~with image-processing techniques.

...... (rather thanScanned images and a road" generated in AutoDesk 3D Studio were

I composited using Photoshop. The final composition included lettering done in Aldus Free- hand and was printed on a Lino-

I: tronic laser image

setter at 200 lines per inch.

"Mathspic." In creating this program, I was able to take advantage of the interfacing routines provided by Windows (potentially I will also rewrite some older packages for this environment). Many math-based programs require the user's control of a number of parameters; it is much easier to explore these programs if one changes these parameters interac- tively (rather than editing one's code, recompiling and running the program again). The interactive interface of Latham's Mutator is a good example of this. I have used the Borland Resource Editor (a programmer's software tool for building Windows interfaces) to create custom dialogue boxes that control my routines (Fig. 7). Figure 8 shows a custom dialogue box in use, including the parameters that generate an image, along with a text panel in a background window with C code showing the calling routine for the dialogue box.

I generated a work called The Car Crash of G.I. Gurdjieff (Fig. 9) in

Mathspic using C-code routines. The curved patterns are a visualization of an inverse-square law attraction between gravitational bodies or electrostatic charges; the patterns are intended to show the force-fields between a central body (symbolizing Gurdjieff, or any charismatic figure) and gravitational bodies that are either drawn towards or repelled from him. The six frames sym- bolize the chaos a master can bring to a community, as well as a final harmony. Other programmed routines create a gradual "embossing" of the image from the bottom of the frame upwards and the progressive darkening from right to left. Neither of these processes could have been easily executed in a commercial program such as Photoshop. How- ever, I used Photoshop to bring together the composition of the program-generated imagery and the scanned images of Gurdjieff and the car. The road was generated in 3D Studio.

In 8 years of teaching programming to artists and designers, I have seen only a handful of students pursue the path of writing (rather than merely using) software packages. Those who have seemed to have had some innate aptitude and sympathy for the approach; interest- ingly, it has been impossible for me to predict the outcome from interviewing potential students. Perhaps a clearer pic- ture of the difference in visual results between the two methods would help deliberating students.

I used to consider it a rule of thumb that it takes about 3 years to become a competent programmer; this is a long period compared to the time it takes to become proficient in the use of Photoshop, for example. One might think that the advent of plug-in programming would simplify things, since others have already written the codes for these programs, but in practice a considerable level of aptitude is required in order to interface with these programs. There are also other overheads: to use AutoDesk's (3D Studio or Ani Pro) and Adobe's (Photoshop) programs, one must not only register as a developer for a fee, but also buy specialized compilers. Writing code for Windows is not for the novice either; as mentioned earlier, one must first select routines from a library of about 1,000, while learning a new programming paradigm. The attractions of Windows, apart from its interfacing libraries, are its ability to be independent of graphics hardware (any Windows- compatible graphics card will run any




Windows program), its inexpensive platforms and the huge potential markets for developing packages with commercial applications.

CONCLUSIONS

The sophistication and complexity of current commercial computer-graphics software means there is less of a demand for the programming skills of artists, designers and animators. On the other hand, in order to create visual outcomes dependent on programmed algorithms, an artist may indeed need to write code, either as a stand-alone or as a plug-in to another package. These pieces of code require not only an advanced under- standing of mathematics and geometry, but also considerable programming skills (artists do sometimes commission code from programmers).

While Franke states that artists univer- sally approach programming through a mathematical or geometrical basis, this in not always the case. Among the examples I have discussed in this paper, Cohen's work is probably the furthest from this approach. His work also chal- lenges the concept of "originality" in art in a way that would not be possible without the use of programming. Con- versely, the use of programming can en- hance the computer artist's claim to originality, as in case of Latham's software programs, which are not intended for distribution. Latham and Sims use programming to simulate an evolutionary approach to image-generation; Cohen uses an AI approach; Harwood and Wright, who are probably represen- tative of a wider range of artists who program, use programming to create effects not available through existing packages. In my own work, I have tended to build

packages for my own use and for others, occasionally also writing one-off software. As a group, the artists discussed in this paper have a wide range of motiva- tions for using programming, which have not been greatly affected by the availability of new commercial packages. However, the group does, in all prob- ability, only represent a small number of artists using computers; others may function perfectly well with commercial software. We will have to leave history to determine which type of computer artists (programmers or nonprogrammers) makes the greater contribution to new art forms in this century and beyond.

References 1. M.R. King, "Development of an Integrated Com- puter Art System," in N. Magnenat-Thalmann and D. Magnenat-Thalmann, eds., New Trends in Com- puter Graphics, Proceedings of the CG International 1988 (Berlin: Springer-Verlag, 1988) pp. 643-652.

2. M.R. King, "Towards an Integrated Computer Art System," in R.J. Lansdown and R.A. Earnshaw, eds., Computers in Art, Design and Animation, Proceed- ings of the 1986 Conference at the Royal College of Art (London: Springer-Verlag, 1989) pp 41-55.

3. M.R. King, "Computer Media in the Visual Arts and their User Interfaces," unpublished doctoral thesis, Royal College of Art, London, 1986.

4. H.W. Franke and H.S. Helbig, "Generative Math- ematics: Mathematically Described and Calculated Visual Art," Leonardo 25, Nos 3/4, 291-294 (1992); and in Michele Emmer, ed., Visual Mathematics (Cambridge, MA: MIT Press, 1994).

5. See M.R. King, "Development of an Integrated Computer Art System" [1] and "Towards an Inte- grated Computer Art System" [2].

6. C. Lindley, Image Processing in C (New York: John Wiley, 1991).

7. G. Harwood, IF Comix Mental (London: Working Press, 1989).

8. H.W. Franke, Computer Graphics-Computer Art (London: Phaidon, 1971).

9. J. Whitney, Sr., Digital Harmony (Peterborough, NY: McGraw-Hill, 1980).

10. D. Em, The Art of David Em (New York: Abrams, 1988).

11. S. Todd and W. Latham, Evolutionary Art and Computers (Academic Press, 1992).

12. J. Pearson, "The Computer: Liberator or Jailor of the Creative Spirit," in Electronic Art, Supplemen- tary Issue of Leonardo (1988) pp. 73-80.

13. P. McCorduck, Aaron's Code: Meta-Art, Artificial Intelligence, and the Work of Harold Cohen (New York: Freeman, 1991).

14. Mark Wilson, entry in Martin Reiser, ed., Elec- tronic Print, an International Exhibition of Computer Art, exh. cat. (Bristol: Arnolfini Gallery, 1989). See also the inside cover of Digital Visions [17].

15. E. Zajek, "Orphics: Computer Graphics and the Shaping of Time with Color," in Electronic Art [12] pp. 111-116.

16. Franke [8].

17. C. Goodman, Digital Visions (New York: Abrams, 1988).

18. Todd and Latham [11].

19. K. Sims,"Panspermia," in C. Schopf and M. Knipp, eds., Der Prix Ars Electronica, International Compendium of the Computer Arts (Linz: Veritas Verlag, 1991) pp. 76-83.

20. Harold Cohen, exh. cat. (London: Tate Gallery Publications, 1983).

21. McCorduck [13] p. 68.

22. McCorduck [13] p. 41.

23. Harwood [7].

24. John A. Walker, Glossary of Art, Architecture and Design, 3rd Ed. (London: London Library Associa- tion, 1992).

25. R.Q. Wright, "Superanimism: The Practice of Formalised Imagery," in Isaac Victor Kerlow, ed., Computers in Art and Design (New York: Association for Computing Machinery, 1991) pp. 85-88.

26. R.Q. Wright, "Some Issues in the Development of Computer Art as a Mathematical Art Form," in Electronic Art [12] pp. 103-110.

27. A renderer is a kind of software that takes a 3D database and creates images from it using a "virtual camera" metaphor. For more on Sculptor, see M.R. King, "Sculptor: A Three-Dimensional Computer Sculpting System," Leonardo 24, No. 4, 383-387 (1991).

28. M. Cass and G. Miller, "Rapid Stable Fluid Dy- namics," SIGGRAPH Conference Proceedings 24, No. 4, 49-57 (1990).




Documents

Programmed Graphics in Computer Art and Animation