GLITCH ART - DATA VISUALIZATION

DATA VISUALIZATION

The purpose of this article is to explain what it is that I actually do
to produce the Glitch Art on this site. As you will see, the Glitch
part is relatively minor compared to all the data-rendering processes
that happen after I've caught my Glitch! For completeness, I've also
included material on the conceptually similar topic of Audio Glitches.

---------------- -----------------
Digital Glitches Analogue Glitches
---------------- -----------------
| |
| |
| -----------------------------
| Analogue-to-Digital Converter
| -----------------------------
| |
|__________________________|
|
|
------------
Digital Data
------------
|
|
---------------
Rendering Agent
---------------
|
______________|_____________
| |
| |
----- ------
Audio Visual
----- ------
| |
| |_______________________
--------------------- | |
Data Segmentation: | |
Bit Depth Alteration ------------- ----------
Interleaving Channels 3rd-Party App Custom App
--------------------- ------------- ----------
| | |
| | |
-------------------------------- ---------------- --------------------
Post-Processing: Intrinsic Images Data Segmentation:
Injective Functions of Amplitude ---------------- Bit-Depth Alteration
Sample Rate Alteration | Choice of Stride
Cropping | --------------------
-------------------------------- | |
|________________________|
|
|
-----------------------------
Post-Processing:
Injective Functions of Colour
Pixel Resizing
Cropping
-----------------------------

ANNOTATION AND COMMENTARY

Analogue Glitches
These we agree about, to a lesser or greater extent.
Here are three, in decreasing order of general consensus.

1. Electrical spike.
2. Chemical disturbance (eg. in brain).
3. Discontinuity of time or space (eg. black hole).

Digital Glitches
These are what I allow.
Others will disagree, it depends who you talk to.

1a. (Visual) The output of a display device which is controlled by
a mechanical or electrical device (eg. computer), whilst that device
is, or has been at any point during its current operating session,
performing operations which are not consistent with its specification.

1b. (Auditory) The output of a sound-producing device which is controlled by
a mechanical or electrical device (eg. computer), whilst that device
is, or has been at any point during its current operating session,
performing operations which are not consistent with its specification.

2. Data emanating directly from the digital hardware components of a device
(eg. the contents of a file on a computer). The data is allowed to have
been produced deterministically, provided that it has been produced
in a complicated way which is unfathomable to humans. (Note. This
does not allow fractals because they are fathomable, and have been so
for about thirty years.)

Having reached this point, we can happily forget about what a Glitch is!
We have our raw material to hand, and now we must consider a
proper framework for rendering that data, either visually or audibly.
We want the rendering process to be physically transparent;
the glitch material should be rendered faithfully without colouration (visually or audibly).

Analogue-to-Digital Converter (ADC)
This is purely a convenience. The ADC should make a high quality approximation
of an analogue source, which allows us to manipulate it (see later) in
the high-power domain of the computer.

I'll go down the Audio side of the diagram first...

Audio -> Data Segmentation
The data can be thought of a stream of binary digits; grouping those
digits into chunks of 8 gives us numbers between 0 and 255 ("8-bit integers"),
for example. By selecting a chunk size or bit-depth as it is properly called,
we control the resolution of the audio samples.

After selecting a bit-depth, a creative possibility would be to send
alternate samples to the Left and Right channels of a stereo output.

Audio -> Post-Processing
I'll explain "Injective Functions of Amplitude" first. Suppose we have
8-bit samples in the range 0 to 255. An injective function whose domain
is this set of integers is one which maps these integers to any set of numbers
which are all distinct from one another.
If x is the original sample amplitude, then functions such as
f(x) = 255 - x
f(x) = x * x
are injective. The whole point about using injective functions is that
they neither create nor destroy structures within the glitch raw material.
Functions (as opposed to relations) cannot create structure.
Injective functions cannot destroy structure.
For example, if this is part of the glitch data stream:
2 0 1 3 2 2 3 1 0 .... etc.
and if f is a function defined by
f(0) = 0
f(1) = 1
f(2) = 3
f(3) = 1,
then the transormed data stream becomes:
3 0 1 1 3 3 1 1 0 ....
This new steam has less structure in it, by which I mean to say
(rather belatedly) it has fewer differences between consecutive numbers.
To emphasize this point, consider a function g:
g(0) = 5
g(1) = 5
g(2) = 5
g(3) = 5,
which transorms the original data stream into:
5 5 5 5 5 5 5 5 5 ....
This data stream has lost all its structure now!
Detail has been lost.
So, you see how non-injective functions such as f and g
destroy structure.

Sample Rate Alteration is self-explanatory, it is a parameter
which can be altered to taste for aesthetic reasons without
altering in any way the underlying glitch data.

Cropping just means selecting a piece of audio of special
aesthetic interest.

That's the audio side done, so now I'll go down the Visual side...

Visual -> 3rd-Party App -> Intrinsic Images
For the purpose of this article, a 3rd-party application
is any piece of software written without regard for the
processing of glitch images. It must be software which is orthogonal
to our business of data-rendering (eg. Space Invaders, Word, Windows 95).

An Intrinsic Image is an image which is generated by a 3rd-party app
whilst processing the glitch data in some way. For example, if I
open up my Windows registry file in an arcade emulator and make the
emulator execute this file, then any output I get in the emulator
display is an Intrinsic Image. (It's intrinsic to the app.) This type
of glitch rendering has similarities with Photography - you wait for
something interesting to happen "out there" (ie. in the app), and then
snap a picture (ie. do a screengrab).

Visual -> Custom App -> Data Segmentation
With custom-written software, you can cut up the binary glitch data
into different bit-depths, just as for the audio.

The glitch data stream is one-dimensional whereas images are two-dimensional,
so we also need to specify a Stride, which determines how many
pixels across (or down) we go before starting the next row (or column).
A good choice of Stride makes a big difference to the aesthetic
of an image.

Visual -> Post-Processing
Colour in images is like amplitude in audio.
Injective Functions of Colour can be applied since they cannot
create nor destroy structure (defined as differences between consecutive
pixel colours).

Pixel Resizing - this is equivalent to stretching an image horizontally
and/or vertically. It's a transparent operation because the image
still looks essentially the same.

Cropping just means selecting a region of aesthetic interest from an image.

GLITCH ART TECHNIK ANTI-FRACTAL