v.
1.2 May 2012
Modern
video feedback art
Algorithmic
Recursive Geometry - Evolving Fractals and Chaos – Image Morphing
Contents
Inserting the images into the flow
Perceptron is a video feedback engine with a variety of extraordinary graphical
effects. It evolves colored geometric patterns and visual images into the realm
of infinite details and deepens the thought.
Home
page… http://perceptron.sourceforge.net
Download….. http://sourceforge.net/projects/perceptron
Gallery……… http://perceptron.sourceforge.net/gallery/index.html
Forum……….. http://sourceforge.net/projects/perceptron/forums/forum/1256631
Background
The classical video feedback is an artistic technique
that uses a video camera and a TV set. The camera and the TV set are connected
by cable so that the TV set can display live images coming from the camera. The
camera is directed at the TV screen – it is shooting the video of TV set
together with the live images on its screen. With a slight delay, the TV set is
broadcasting the video output from the camera. The TV screen develops a
recognizable pattern, live image of screens within screens shrinking towards a
bright point in the middle of screen. By using a camera and a TV set only, we
can see a variety of fractal spirals and specifically, saturation-related or
pixel-related effects that stem from the electronic components. They are
obtainable by rotating the camera around its axis slightly and zooming in. With
a single mirror located next to the TV screen, we can additionally create
fractal trees, and by adding even more mirrors, we can create complex IFS
fractals. The effect of mirrors is equivalent to linear geometric
transformations applied to the screen contents. Every geometric transformation
in the video feedback cycle of visual data is applied repeatedly (recursively)
to the screen contents. [1]
To the left (below), we can see my Web Camera pointing at the computer
screen that is simultaneously displaying what the camera sees. To the right, I
placed my finger in front of the camera and it was multiplied. Once you insert an
object in front of the camera, the image is formed slowly and inwardly. The
relationship between the size and position of my finger and the size and
position of its first consecutive copy (slightly smaller one to the left) gives
us the geometric transformation that is applied recursively to the screen
contents in the video feedback cycle. Inserting the objects before the camera
is also known as “inserting the image into the video feedback flow” or as
“staining the flow” when a simple color is added to the flow and it colors the
screen.
In the following experiment, I placed a small mirror next to the camera’s display on my
computer screen, and a wondrous world was revealed. Can we learn to inhabit and
explore such new world?
The display is constantly fluctuating because the camera is
readjusting its sensitivity depending from the level of light in its view. When
the fluctuations on the screen begin to increase, the camera also begins to
readjust its sensitivity more wildly. Such behavior leads to possible chaos.
The camera and the screen represent a dynamical feedback system. To see
examples from other artists, see here and here.
Perceptron
Perceptron simulates the essence of classical video
feedback setup, although it does not attempt to match its output exactly. For
example, it does not simulate the relationship between the TV set, the camera
and the mirrors in space, or the effects due to electronic components. Instead,
it uses a two-dimensional computer screen only in order to transform (morph)
geometrically its contents. It applies any given complex function f(z, c) that
maps each point of the screen to a new location. When repeated, the
transformation produces a Julia fractal. This is unique to Perceptron. The
selected (or typed in) function is coupled with the pullback effect (with
rotation) that zooms in and out. See [2] for
examples. This is intuitively similar to the camera zooming into the screen.
I morphed the beautiful girl photo recursively by applying f = z2
- 0.66406214 - 0.24218677i and the pullback effect.
A set of coloring techniques is responsible for the Julia fractal
contours, the visibility of gradient shape and reflections that are reminiscent
of semi-transparent layers, and the color saturation effects. The coloring
techniques stem from the boundary condition check performed on the point z’ =
f(z, c). The default type of check answers whether the point z’ is inside or
outside the invisible limit circle with radius 1. The coloring techniques are the
outside coloring methods, the color gradients, the fade-to color modes, and the
color filters.
With different coloring techniques, known Julia fractal begins to
emerge.
The “reflection transform” multiplies the resulting Julia fractal. It
returns the points mapped outside of the screen dimensions back within the
screen. This yields complex IFS fractals comprised of Julia fractal fragments.
This is intuitively similar to the effect of mirrors, but can be more complex.
Video feedback fractals represent unique and remarkable class of
fractals, a combined Julia and IFS kind of fractals. Perceptron is both an
artistic and a scientific visualization tool of these fractals. Here are some
of the Perceptron’s animations… (The videos are extremely compressed to
reduce size.)
References:
[1] http://classes.yale.edu/fractals/Labs/VideofeedbackLab/VideofeedbackLab.html
[2] http://en.wikipedia.org/wiki/Conformal_pictures
Find
out more online…
http://en.wikipedia.org/wiki/Video_feedback
http://en.wikipedia.org/wiki/Fractal
Distribution
Perceptron is a free, open source program written in Java (www.java.com), and licensed under the GNU Public License
GPL version 3.
Primary author: Michael Everett Rule (mrule7404@gmail.com).
Documentation and further development (v0.9 – v1.2): Predrag L.
Bokšić (junkerade@gmail.com)
Perceptron
runs on all operating systems that
have Java environment installed. Install Java version 7 from www.java.com first. (At this moment, the direct download link
to Java Runtime Environment (JRE) is here.) If you
have a 64-bit operating system, you can install 64-bit Java. Java is used on a
regular basis by web browsers that are not built for 64-bit systems, so most
people should install 32-bit version of Java or both versions at the same time.
If you
are using Windows operating system,
download and run the
windows installer version of Perceptron. It will install Perceptron into the default
location for programs, c:\Programs and Files.
The windows installer will put 32-bit and 64-bit shortcuts on your desktop to the Perceptron executable files. One of the two shortcuts will definitely be suitable for your computer regardless of Java version that you have. The third shortcut, Perceptron Settings can be used to edit the Settings.txt file in a text editor.
For the
manual installation, use the following procedure.
There
are two versions of Perceptron available for download, two ZIP archives, with the source code
included and without the source code included (a.k.a. executable only). Most
users should select the executable only version. Unpack it to any folder where you
have access, such as D:\ or My Documents on Windows systems, or in your Home
folder on Linux, etc. That will create a folder named Perceptron.
If you
are using Windows, enter the
unpacked folder Perceptron, and double-click (execute) Perceptron.exe or Perceptron
64.exe. You can also try to
execute the oldfashioned perceptron32.bat
or perceptron64.bat depending from
the type of computer that you have (32-bit or 64-bit). All new computers are
64-bit machines, but many people do not have 64-bit version of Windows and
64-bit version of Java installed, so 32-bit version should be good. You can
drag the file perceptron.exe to your desktop while holding it with the right
mouse button, and drop it onto your desktop. Windows will offer a menu to
create the shortcut to the file. Then, you will always be able to double-click
the shortcut and run Perceptron. The folder Perceptron contains the icon file icon.ico that you can assign to the
shortcut by right clicking it and editing its properties, if necessary.
If you
are using Linux, enter the unpacked
folder Perceptron, and double click (execute)
the perceptron32.sh or perceptron64.sh depending from the type
of computer you have (32-bit or 64-bit). 64-bit computers require 64-bit Linux
and 64-bit Java. (Notice that the latest Linux systems such as Open Suse may possess capability to execute Java
programs directly, by double-clicking the Perceptron.jar
file.) You can drag the file perceptron32.sh to your desktop while holding it
with the right mouse button, and drop it onto your desktop. Linux will offer a
menu to create the shortcut to the file. Then, you will always be able to
double-click the shortcut and run Perceptron. The folder Perceptron contains
the icon file icon.ico that you can
assign to the shortcut by right clicking it and editing its properties.
In you
want to run the program manually, go
to the console and execute java –d32
–jar Perceptron.jar or java –d64
–jar Perceptron.jar for 64-bit operating system. In Linux, these commands
are usually formatted as java –d32 –jar
./Perceptron.jar and java –d64 –jar
./Perceptron.jar. In Windows, it is possible to double-click the file
Perceptron.jar directly and run it. Unfortunately, I noticed that Perceptron
runs slower if I run it directly like that. The difference is due to a single
option, -d32, that is not evoked by default if you double-click Perceptron.jar.
(The options –d32 and –d64 are available in Java version 7.)
In case
of any problems, you can try to reserve the additional memory space by
executing the following command, java
–d32 –Xms512m –Xmx1024m –jar Perceptron.jar or java –d64 –Xms512m –Xmx1024m –jar Perceptron.jar. (Do not
artificially limit the available memory to a very small value, because the
program will run into error.)
If you
wish to see the source code, participate in the development and compile the project, then download and unpack the ZIP archive with the
source code included (the larger of two). Furthermore, install NetBeans
environment and the
JDK (Java Development Kit) version 7 from here. The development is possible on any operating system.
In NetBeans, open the project (Perceptron folder) from the File menu, and press
play (run). (This type of execution is also fast.)
After startup, it takes a
few seconds for the first fractal image to appear in Perceptron. Fractals in
Perceptron are evolving forever. They are never final. However, depending from
the equation (complex function f(z, c)) and the selected reflection transform,
some are changing a lot, while others are mostly static.
Perceptron is controlled by keyboard and mouse. Almost all keys on the
keyboard are in use – they are associated with the program options. Read the on-screen help by pressing the key / (slash). Here is the look of the help
screen.
The mouse controls any one of the four basic cursors. At startup (as
well as upon loading a preset), neither cursor is selected. Click left or right
mouse button to select a cursor.
Red
cursor: sets the
parameter c of the complex function (e.g. f(z) = z2 + c), (mimics
the camera position).
Blue
cursor: controls the
pullback, (mimics the camera distance and rotation).
Yellow
cursor: sets the color
gradient parameters, offset and slope.
Dragonfly (black cursor): controls the amount and
type of color filtering (contrast) in combination with the X switch.
The red cursor controls the parameter
c with its position, c = (x, y). The center of screen represents the
coordinate zero (0, 0), while the edges of a typical square screen are at about
1.1 units away.
The blue cursor controls the rotation and the pullback. If you rotate it around the coordinate zero, the whole
fractal rotates, but at the same time, the parameter c rotates as well. If you
move the blue cursor closer to the coordinate zero, you mimic the situation in
which you move the camera away from the screen. This is analogous to the image
of screens within screens diminishing in size and contracting towards the TV screen’s
middle. If you move the blue cursor away from the coordinate zero, you zoom in,
i.e. you simulate the camera approaching the screen. Press End to disable or
enable the pullback.
It is best to see how the yellow cursor and the dragonfly cursor
behave in practice. They control the application of the radial gradient, a
matrix of shadow intensities that is used for the basic, gray-scale coloring of fractals. For example, if
you move the yellow cursor to the lower left corner, you will see the classical
Julia fractal in clear black and white. Other positions on the screen will
reveal the effects of other coloring techniques, reflections, and even saturate
the fractal with details. In combination with the X switch, the black cursor
controls the shading of gray-scale Julia contours and if the fractal is full of
lively colors, it has a large influence over the evolution of chaotic colored
patterns.
Cursors are typically decorated with small circles (dots) that follow their motion. The cursor motion is slowed, because it
smoothens the morphing of Julia fractal. It appears as though the cursor is
dragging a weight on an elastic rope. Both features are optional and are
adjustable by pressing =, - and ], [.
The activation of the rotating
three-dimensional fractal Tree will bring up the additional, temporary set
of 4 cursors that control the tree (its position and design). You can select
any cursor by clicking left or right mouse button. The Tree is an artificially
inserted IFS fractal for artistic purposes, which you can bring about when you
press T. When you deactivate it, the tree-related cursors disappear.
The visibility of all active
cursors can be switched off and on by pressing C.
The initial fractal is
defined in the default preset file Perceptron\presets\1.state.
The screen resolution is given in
the settings file, Perceptron\Settings.txt.
If you installed windows installer version of Perceptron, the shortcut to the
Settings.txt file is on your desktop. Otherwise, open the folder Perceptron,
hold the file Settings.txt with the right mouse button, drag it and drop it to
your desktop. Double click the shortcut to edit the file manually. Current
default resolution is 640 × 640 pixels. This allows my computer (featuring the
Intel E5200 processor and the ATI Radeon 2600 HD graphics card) to achieve 16
frames per second. If you achieve the frame rates far beyond the abilities of your
monitor, you may wish to choose a higher resolution or slow the program down by
pressing U. (Pressing U cycles through 4 degrees of speed moderation.)
Do not change the contents of the resource folder unless you know what
you are doing. You need the settings file, at least one preset, one image file
(usually the one denoted in the default preset), CrashLog.txt, cursors folder
with the cursor images (icons), and possibly other files, especially if you are
working with an experimental version.
The settings file contains parameters such as the presets folder and the image
folder, which denote the locations from which Perceptron preloads all
presets and all images at startup. The order of file loading is according to
the names of files (by numbers first, then by alphabet). The preloaded presets are accessible by
pressing S or A. The images are
accessible in the image modes (L = 1
or 2) and in the fractal mode (L =
0) combined with certain outside coloring methods (such as E = 3 or 4). A preloaded image can be selected by
pressing M or N. The loaded image morphs on the screen (together with the mouse
cursors) according to the selected program options, namely the complex function
(also known as the “fractal map” or simply “equation”) and the reflection
transform. You can load a single preset
later during operation by pressing `, or you can load a single image by pressing \. All presets and images loaded in
the course of operation are held in program memory. They are added to the
preloaded presets and images, and are available by pressing S, A or M, N
respectively.
In addition, you can add your own complex
functions (equations) to the list in the settings file. They are available
by pressing W or Q. You can type an
equation in during runtime by pressing CTRL once, typing the equation and
then pressing Enter. Press CTRL again to stop editing the equation. This way
you will exit the equation edit mode,
deactivate the text cursor and return the controls to keyboard (return the
default key assignments.) Hint: you can play with the colorful letters by
typing text anywhere on the screen without pressing Enter (as to avoid entering
a new equation made of silly text). The colorful letters represent the Salvia mode (press ; to disable or
enable, and D to change the color scheme). The successfully typed-in and
executed equations are added to the list of equations in memory (available by
pressing W or Q), but are not saved to the hard disk otherwise, except for the
current equation that will be saved when you save a preset.
The equations in the settings file, those that you type in, as well as
the ones stored in presets are in the form of f(z). For example, z*z gives the
default Julia fractal. You can also write that as z^2. This is a well-known
short form of znew = zold2 + c.
The safest way to operate Perceptron is to do things slowly and wait
for the program to respond, for example, when you load or switch images and
type in equations.
The save option appears when you press Space. It will
save the state (preset file with .state extension) and the screenshots (two
consecutive frames with extensions .in.png and .out.png) in the My Documents
folder (or anywhere else as you select). Sometimes it is knowledgeable to study
the evolution of the complex fractal displays by comparing the difference
between the two consecutive frames. In some situations, the difference is not
visible to the naked eye. The only noticeable difference may be the slight
image softening (Gaussian blur) that the final image acquires. This image is named
name.out.png. I recommend Picasa viewer for all your images, http://picasa.google.com.
The CapsLock is temporarily assigned as the save button during the equation editing mode (if for some
reason, you wish to save a preset at that exact moment). Note that if you load
a preset with the equation-editing mode enabled, the default key assignments
will be temporarily unavailable until you press CTRL and exit the edit mode.
The saved presets are available by pressing ` (BackQuote),
which calls the Open File menu, or by placing the saved presets in the
resource\presets folder before the program starts. The name of the image file
that was used at the time of operation is written in each preset. Make sure
that the specified image file exists on your hard disk at the time of opening
of preset. (Alternatively, a preloaded image from the resource\images folder is
used.)
The animation
mode starts when you press Home. Firstly, a menu will appear that requires
you to select a folder. After that, Perceptron will begin saving the finalized
consecutive frames named frame0.tga, frame1.tga, frame2.tga… It will erase any
files with the same names in that folder without asking. I suggest making a new,
empty folder. The animation mode will stop when you press Home again. The
animation mode is slightly slower than the normal mode of operation. Remember
to perform your planned actions slowly.
Warning: The animation
recording creates potentially extremely large number of TGA (Targa) image
files that you need to bind together into a motion picture. To bind the frames
into a movie, you can use the world’s leading free video tool called FFMpeg. The 32-bit version of ffmpeg.exe for Windows has been
included in the Perceptron folder.
To check the latest version, download the static build from http://ffmpeg.zeranoe.com/builds. It comes in the form of 7Zip archive
that can be unpacked with the free tool you will find at http://www.7-zip.org. Enter the unpacked FFMpeg folder, enter
the bin folder, and copy the file
ffmpeg.exe to the perceptron folder for convenience of access. Linux users
should download from their software package provider.
In the windows console mode, enter the perceptron folder and execute
the following command: ffmpeg –f image2
–r 16 –i .\animations\frame%d.tga .\movies\my_movie.mkv. This assumes the default
locations where the recorded frames are and where you want to generate the
movie (animation), but they can be different depending from where you saved the
frames, and where you want the movie file to be generated. The command –r 16 means that you want 16 frames per
second used for making the final movie. Set this number to the speed at which
Perceptron worked during the animation mode. You can find out what speed that
is if you press z. The frame rate will be displayed in the upper left corner. The
.mkv extension means that you want
the movie to be in Matroska format, which provides rather high quality with
solid compression. Later, you can remove the TGA images, because they occupy a
lot of hard disk space.
If required, you can use the free program StaxRip for video
conversion, http://staxmedia.sourceforge.net, or ffmpeg with one of its many frontends such as Avanti.
I recommend VideoLAN player (in case you need any) to see the movie, http://www.videolan.org.
Perceptron upholds the infinite, circular
flow of pixels (their colors), or in other words, visual images. The visual
images evolve quickly, slowly or endlessly depending from the geometric
transformations that are occurring between the two stages along the flow, the
screen and the buffer memory.
Perceptron uses 4 matrices of equivalent
format: screen, buffer (temporary screen contents holder), lookup table, and gradient
matrix. All 4 matrices are used in coordination, that is, we focus on a
single element from each of the 4 matrices at a given time in order to update a
single pixel of the buffer. For speed purposes, all matrices are stored in the form
of one-dimensional arrays.
The flow of visual images starts with the
screen matrix and follows to the buffer matrix. The screen represents the
portion of the complex plane around the coordinate zero, no bigger than the
circle of radius r = 3. The first or initial visual image (frame 0) needs to be
copied (“mapped”) from the screen to the buffer. The buffer will fill its
element (pixel) at the position z = (x, y) by reading the position z’ = f(z) at
the screen. The complex number z’ is precalculated and stored in the lookup
table at the position z.
Next, we test to see whether the point z’
is inside the limit circle of radius r = 1 or outside (depending from the
boundary condition). If it is within the circle, the color read at the screen
position z’ is color inverted and copied to the buffer at position z. If the
point z’ is outside the limit circle, some color is added to the existing pixel
color found at the screen location z’, after which it is color inverted, and written
to the buffer at position z. The added color depends from various coloring
functions. Primarily, it is a color value (“shadow intensity”) taken from the
gradient matrix at the position z. The gradient matrix is precalculated and
filled with a shape such as the radial (round) shadow, black in the middle and gradually
whiter towards the edge. When all pixels of the buffer are filled, the buffer
is copied to the screen directly. Over several cycles, this creates a
gray-scale Julia fractal with black and white contours.
The mentioned color inversion affects pixels
read at the screen position z’ both when z’ is inside the limit circle and when
z’ is outside the limit circle (that is, regardless of the boundary condition
check). We call it the total color inversion that affects the entire flow of
visual images (all screen contents). You can find the option to disable the
total inversion in the help menu. The partial color inversion refers to the
situation when the total color inversion is enabled, but you want to color
invert the fractal that you have in front of you on the screen. The total color
inversion is responsible for the concentric, interchanging Julia contours (e.g.
black and white), and the partial color inversion is a switch that replaces the
black contours with white and white with black.
Let us step back to the situation right
after the boundary condition check. If the point z’ is beyond the screen matrix
size, the “reflection transform” moves it inside (contracts it) by the
application of somewhat nonsensical linear functions. The color is obtained
from the screen after all, color inverted, and passed on to the buffer. This
creates multiple “reflections”, simple copies of Julia fractal portions
(fragments) that form IFS fractals. The linear functions are equivalent to the
affine transformations used to create IFS fractals in the ordinary fractal
generators.
A single cycle is complete when the buffer
sends (copies) its contents to the screen as they are. This initiates a new
cycle of geometric transformation from the screen to the buffer. Over the
course of many cycles, the exquisite combination of Julia and IFS fractals
emerges. The age of a video feedback fractal is expressed by the number of
cycles performed, which is also known as the number of iterations. The age
determines the recursive depth (e.g. number of concentric Julia contours added
inwardly).
The combined Julia and IFS fractals
sometimes occur as the effect of branch cuts of certain complex functions when
they are used in the conventional fractal generators (such as Fractint and UltraFractal). See for example, http://ultraiterator.blogspot.com.
Boundary Condition (R) – the boundary condition for points
z’.
0
Rectangular
Window (as the “limit circle”)
1
Limit
Circle (for classical Julia sets)
2
Elastic
Limit Circle (the limit circle size is tied with the blue cursor)
3
Horizontal
Window
4
Vertical
Window
5
Inverse
Oval Window (the inverse check on oval window)
6
No
Window (move on to outside coloring)
7
Framed
Window (with a colored frame)
8
Convergent
bailout condition (for Newton fractals)
Outside Coloring Method (E) – what to do with the points z’ that
are “beyond” according to the boundary condition check.
0
Fill
With Fade-to Color
1
Edge
Extend (pass on the color for points within a large screen)
2
Just
Pass on the Color
3
Paint
With Image (loaded image appears on fractal contours)
4
Paint
With Image II (image with soft edges)
5
Fuzzy
(a type of color average around the location z’)
Reflection Transform (I) – the contraction of points z’ back
within the screen limits.
Let z’ = (x, y),
while Width and Height denote the screen dimensions (W, H). The point z’ can
reach the positions between 0 and W – 1,
and 0 and H – 1. Make x and y positive.
0
Shrink
z’ to x = W – 1 – x modulo W, and y = H – 1 – y modulo H.
Perform the pixel interpolation (rounding
of pixels and enhancement of image quality).
1
If x
/ W is even, x = x modulo W, otherwise x = W – 1 – x modulo W.
If y / H is even, y = y modulo H,
otherwise x = W – 1 – x modulo W. Without the interpolation, but in use by the convolution procedure
that adds a layer over images (for softening).
2
Same
as 1, but with pixel interpolation.
3
x = x
modulo W / 2, y = y modulo H / 2. With interpolation.
4
If x
> W – 1, x = x modulo W, otherwise x = W – 1 – x modulo W.
If y > H – 1, y = y modulo H, otherwise
y = H – 1 – y modulo H. With interpolation.
5
If x
< W, x = x modulo W / 2, otherwise x = W – 1 – x modulo W.
If y < H, y = y modulo H / 2, otherwise
y = H – 1 – y modulo H. With interpolation.
6
If x
/ W is even, x = x modulo W / 2, otherwise x = W – 1 – x modulo W / 2.
If y / H is even, y = y modulo H / 2,
otherwise x = W – 1 – x modulo W / 2. Performs the additional operation of
making x, y positive, because they could become so large
(>2147483647) that they wrap around and come up as negative numbers. With
interpolation.
7
If x
/ W is even, x = x modulo W / 2, otherwise x = (W – 1) / 2 – x modulo W / 2.
If y / H is even, y = y modulo H / 2,
otherwise x = (W – 1) / 2 – x modulo W / 2. Performs the additional operation
of making x, y positive, because they could become so large (>2147483647)
that they wrap around and come up as negative numbers. With interpolation.
Color Gradient (G) – the color added to the points z’
that are “beyond” according to the boundary condition check.
0
No
Gradient (do nothing)
1
Simple
Gradient (gradient affects the color)
2
Accented
Gradient (accent color plays an additional role)
Gradient Shape (‘) – the shape of the two-dimensional
shadow used for basic gray-scale coloring.
The gradient shape can be visible on the
contours of a typical Julia fractal, which in turn can be uniformly colored
(without any indication of the gradient shape), or varied (which shows the
gradient shape). Each of 10 gradients was made by the calculation of various
functions of two variables. The default gradient (0) is the radial shadow,
black in the center and gradually whiter towards the perimeter.
Suppose that the Julia set is a circle.
When you change the proportions of screen (by adjusting the screen resolution),
the Julia fractal becomes an ellipse. The radial shadow also becomes elliptic.
This behavior is considered more natural for a video feedback system, because
its displays depend from the shape of the screen. The contours of the Julia fractal
behave similarly to the images of screens within screens in the classical video
feedback setup.
Gradient Direction (K) – whether the gradient shade is going
from black to white or from white to
black.
Fade Color Mode (F) – the fade-to color mixed with the
existing color of the point z’ outside the limit circle.
0
Black
1
White
2
Mid-Screen
Pixel Hue (select the color from the middle of the screen)
3
Not
Mid-Screen Pixel Hue (select the negated color value of the mid-screen pixel)
4
Mid-Screen
Pixel Hue Rotate (rotate the hue through HSV color spectrum and combine it with
the mid-screen pixel color)
5
Hue
Rotate (rotate the hue through HSV color spectrum)
Dampen Fade-to Color (V) – a small dampening of fade-to color.
Color Accent (H) – choose the accent color.
Color Filters (X) – the contrast enhancements.
0
None
(do nothing)
1
RGB (various
filters and color functions play a role)
2
Mush
(various filters and color functions play a role)
Partial Inversion (Insert) – partial inversion of colors
affects the fractal contours; black can become
white and white black.
Thanks to the total color inversion that
affects the entire visual image in each cycle, we have the interchanging Julia
contours, but consequentially the Julia lake flickers. The partial inversion
does not affect the flicker. It acts as the conventional color inversion of the
current screen contents.
Total Inversion (J) – disables the fundamental color
inversion.
The flickering of the Julia lake stops,
but the contours disappear as well. The visibility of fractals depends from the
fractal map (since some Julia fractals do not possess any lakes), and the
presence of other images on the screen (notably the screen cursors).
Convolution (Y) – adds a layer that softens and blurs
the image.
Even though it is technically a blur, this
improves the quality of image greatly. It is combined with the selected
reflection transform. When I disable the convolution, I achieve a speed
increase from 16 to 20 frames per second with default settings.
Autorotation, Autopilot and
Wanderer (, . p Delete) – continuous random change of
different parameters.
Fun () – for speed purposes, we do not time
your usage of Perceptron.
Inserting
the images into the flow
One of the fascinating research options is
to insert different images, live feed from a web camera, or geometric patterns
produced in various processes into the video feedback flow. The rotating
three-dimensional fractal Tree is one such insertion. It enables one to
understand the morphing of images under the given geometric transformations.
The insertions allow us to understand the dynamics of fractals and discover
brand new patterns. If you have any idea what to insert into the flow and how,
or wish to expand the theory of video feedback fractals, please join the forum of send us
an email.
Be Intuitive!