Shape Generation using Cellular Automata with

Clustering?

Caleb Zeeman1[0000−0002−4937−3401] and Lynette van Zijl1[0000−0001−5735−0448]

Dept. of Computer Science, Stellenbosch University, South Africa

[email protected],[email protected]

Abstract. When using cellular automata with clustering in the Lumer-

Faieta ant sorting algorithm, the method used to drop the cells in a
cluster affects the geometric shape that the cluster will form. We in-
vestigate various algorithms for dropping strategies that can be used to
generate pre-defined geometric shapes.

Keywords: cellular automata · clustering · shape generation

1 Introduction
Cellular automata with clustering (CCA) is a hybrid form of cellular automata
(CA), where adjacent cells with the same attributes are allowed to join into a
super-cell named a cluster [1, 9, 10]. The cluster information is stored extraneous
to the cellular automaton itself. When a cell in a cluster is updated via the CCA
rule, all the cells in the cluster are synchronously updated to the same attribute
value. Both Adams [1] and Smal [9] showed that CCA typically require fewer
time evolutions to achieve a goal than is the case with CA.
In this article, we consider the application of CCA to shape generation. The
use of CA in shape generation has been considered before [3, 4, 8, 12], but due
to the single cell model, the shape formation is not easy to achieve. Delormea
et al. [4], for example, used signals in grouped cellular automata based on the
mathematical definition of the shapes, whilst Chavoya and Duthen [3] evolved
a shape from a single cell in a 2D grid, by using genetic algorithms to update
lookup tables for the CA. In the case of CCA, we show that simple geometric
shapes such as circles or squares can quite easily be explicitly forced in CCA. The
CCA model used for the shape formation is the standard Lumer and Faieta (LF)
ant sorting model [7]. In the LF model, an ant picks up a single object, and drops
a single object. The CCA model is identical, except that an ant picks up a cluster
of objects, and drops a cluster of objects. This requires a dropping strategy, as
the objects in the cluster have to be dropped in open cells in the immediate
vicinity of the target cell. We design three families of dropping strategies, and
show how these determine the geometrical shape of the cluster, based on different
algorithms for the dropping strategies.
?
This research was supported by the National Research Foundation, grant number
133051
2 C. Zeeman, L. van Zijl

Sect. 2 gives a brief overview of CA, CCA, and the LF ant sorting model.
Algorithms for different dropping strategies are investigated in Sect. 3, with a
discussion on how these strategies affect the shape that the clusters form. We
conclude in Sect. 4.

2 Background

It is assumed that the reader is familiar with the theoretical background to CA,
such as in [11].

2.1 Cellular Automata

A CA is a discrete system that consists of a k-dimensional array of automata

that execute simultaneously. Automata in the array communicate by means of a
CA rule. Typically, this rule concerns the automata that are in close proximity
in the array – that is, an automaton is affected locally by the other automata
in its immediate neighbourhood. The CA execute in concrete time steps, where
the state of the automaton in cell ci at time step t + 1, is determined by the
state of both ci and its neighbours at time step t, via the CA rule. These time
steps are known as the evolution of the CA. The array can be considered to
be bounded on all sides (null boundary CA), or to be connected on opposing
sides (periodic boundary CA). In this article, the generation of geometric shapes
in two dimensions are considered, and hence only two-dimensional grids with
periodic boundaries are investigated.
The idea of a neighbourhood in CA is defined by means of a distance r,
and geometrical adjacency of cells. For example, the well-known Von Neumann
and Moore neighbourhood for a cell at coordinates (a, b) in the grid, is defined
respectively as

r
N(a,b) = {(i, j) : |i − a| + |j − b| ≤ r} . (1)

and
r
N(a,b) = {(i, j) : |i − a| ≤ r, |j − b| ≤ r} .

Thus, any cell in the Von Neumann neighbourhood of the cell (a, b) for dis-
tance r = 1, is geometrically adjacent to it; that is, the cells share a common
border. Likewise, any cell in the Moore neighbourhood of cell (a, b) for r = 1,
is either geometrically adjacent to cell (a, b) or it is geometrically adjacent to
another cell which is adjacent to (a, b). Note that cells that are diagonally con-
nected are not considered to be adjacent. Hence, to include cells that are diagonal
to (a, b) in the Moore neighbourhood, a connected path of adjacent cells from
(a, b) to the target cell, can be constructed. The idea of neighbourhoods and
adjacency of cells are important in the CCA shape generation, and is discussed
in more detail in Sect. 2.2 and Sect. 2.4.
 Shape Generation using Cellular Automata with Clustering 3

2.2 Cellular Automata with Clustering

Two-dimensional CA with clustering was first proposed by Smal [9], and ap-
plied to a pattern layout optimisation problem. The idea of biological cellular
clustering is well-known, but normal CA models function only on a single cell
behaviour. Deutsch et al [5] point out the collective behaviour in biological mul-
ticellular organisms, and in particular the issue of collective migration, which
reflects the idea of clusters as applied in CCA.
Informally, a cluster is a collection of adjacent cells with the same attribute
values. Thus, a cluster has no predefined shape or size, and it becomes necessary
to redefine the idea of adjacency for clusters. Otherwise, it would not be possible
to determine the neighbourhood of a cluster. The definitions from [1] are briefly
summarised (see Fig. 1).
Two cells c(i, j) and c(u, v) in a grid are properly adjacent if they share a
common geometric border. That is, |u − i| + |v − j| ≤ 1 (see Eq. (1) above).
Consider a graph with the cells as nodes, and an edge between two nodes only
if the corresponding cells are properly adjacent. Properly adjacent cells are then
also properly connected. This enables the definition of a cluster as a set of prop-
erly connected cells. Given any two clusters A and B, the clusters are properly
adjacent if there exists at least one cell a(i, j) in A and at least one cell b(k, m)
in B, such that a(i, j) is properly adjacent to b(k, m). For example, the Von
Neumann neighbourhood of distance r for a cluster A is given by

NAr ={B : ∃cij ∈ B such that |i − a| + |j − b| ≤ r and

∃ ckm 6∈ A and cab ∈ A such that
|a − k| = 1 and |b − m| = 0 or
|a − k| = 0 and |b − m| = 1}.
Similarly, for the Moore neighbourhood of a cluster, one has:
NAr ={B : ∃cij ∈ B such that |i − a| ≤ r and |j − b| ≤ r, and
∃ ckm 6∈ A and cab ∈ A such that
|a − k| = 1 and |b − m| = 0 or
|a − k| = 0 and |b − m| = 1}.
Fig. 1 illustrates the concept of the neighbourhood of a cluster. Consider a
cluster consisting of cells {c12 , c13 , c21 , c22 }. Its Von Neumann neighbourhood
consists of all cells which are properly adjacent to at least one cell in the cluster.
For example, c20 must be in the Von Neumann neighbourhood, as it is properly
adjacent to c21 . On the other hand, c33 shares no common border with any of
the cells in the cluster, and hence is not in the Von Neumann neighbourhood of
the cluster.

2.3 Ant Sorting Using the Lumer and Faieta Model

Lumer and Faieta [7] provided a CA model which reflects the sorting behaviour
of ants, where corpses are organised into piles known as cemetries. This model
4 C. Zeeman, L. van Zijl

00 01 02 03 04

10 11 12 13 14

20 21 22 23 24

30 31 32 33 34

Fig. 1: Von Neumann neighbourhood for cluster {c12 , c13 , c21 , c22 }.

is useful in practical applications ranging from optimisation problems to dis-

tributed control [6].
In the Lumer and Faieta (LF) model, a number of objects are initially ran-
domly placed on a grid, where each cell can contain at most one object. Ants
are then randomly placed across the grid. At each time step, these ants move
randomly to an adjacent cell. Before it moves, if the current cell is not empty,
the ant may pick up the object with a certain probability, and carry it to the
adjacent cell. Likewise, if the ant is carrying an object, and the current cell is
empty, the ant may drop the object with a certain probability and move unladen
(without carrying an object) to the adjacent cell. The pickup and drop probabili-
ties depend on the density of objects with the same attributes that are located in
the neighbourhood of the current cell. This density is reflected by the so-called
fitness function f (oi ) of an object oi . In the simplest form of the LF model,
each object is assigned a certain colour, and the goal is then to sort objects of
the same colour into one vicinity on the grid. Informally, if an ant encounters
an object, it will pick up the object if the surrounding neighbourhood does not
contain many other objects with the same attribute. Likewise, if an ant carries
an object, the probability of dropping the object in a certain cell will increase
if there are many objects with the same attribute in the immediate neighbour-
hood. For the mathematical details of the fitness function and the pickup and
drop probabilities, see [7].

2.4 Ant Sorting Using Clustered Cellular Automata

Adams [1] provided an adaptation of the LF algorithm for CCA (see Algo-
rithm 1). In principle, the main modification to the original LF algorithm is
that an entire cluster of objects is picked up and dropped by an ant, instead of
only individual objects. At the completion of the time step, any adjacent clusters
with the same attributes are merged into a single cluster.
The dropping of a cluster requires some clarification. To drop a cluster, an ant
moves into an empty cell. Since all the objects in the cluster cannot be dropped
into this single cell, the cluster must be distributed across empty cells in the
surrounding area. The dropping strategy determines how these extra empty cells
 Shape Generation using Cellular Automata with Clustering 5

are located, and the resulting shape of the cluster on the grid varies depending
on the dropping strategy employed.
If there are not enough empty cells found to fully drop the cluster, the original
cluster is split into two clusters. The cells already dropped form one cluster, and
the other cells still being carried are joined into a new cluster, which remains
as the ant’s payload. The ant will then continue to search for a new dropping
location.
In addition, note that when a cluster ci is dropped directly adjacent to an-
other existing cluster cj (typically with the same attributes), the cells in ci are
dropped into empty cells next to cj . This may lead to the formation of joined
partial shapes during the time evolution of the CCA in the shape generation
process.

Algorithm 1: The modified Lumer-Faieta algorithm for clustering

for every object oi do
place oi randomly on grid;
for all ants do
place ants at randomly selected site;
calculate clusters;
for t = 1 to tmax do
for all ants do
if (ant unladen) and (site occupied by object oi in cluster cj ) then
compute f (oi ) and ppickup (oi );
select random real number R between 0 and 1;
if R ≤ ppickup (oj ) then
pick up cluster cj ;

else if (ant carrying cluster cj ) and (site empty) then

compute f (oi ) and pdrop (oj );
select random real number R between 0 and 1;
if R ≤ pdrop (oj ) then
drop cluster cj ;
move to randomly selected neighboring unoccupied site if available,
else do nothing;

3 Shape Generation

In order to generate a given geometric shape in the ant sorting model, objects in
a cluster need to be dropped so that the required shape forms on the grid. Note
that geometric shapes can be formed by dropping the objects in relation to the
current cell, in a specified order. For example, to form a straight horizontal line
6 C. Zeeman, L. van Zijl

of width one, the objects in the cluster need to be dropped to the right (or the
left) of the current cell. Likewise, to form a perpendicular line of width one, the
objects need to be dropped to the top (or bottom) of the current cell. However,
in the ant sorting model, clusters are typically dropped adjacent to other clusters
with the same attributes. This means that not all the cells around the current
cell are necessarily empty, and therefore the dropping strategy needs to search
for the ‘best’ open cell to drop an object. The method of determining the best
cell can influence the eventual shape that forms.
Hence, any dropping strategy must identify the current cell, the neighbour-
hood to be explored for an empty cell, the order in which the neighbourhood
will be explored, and a method to define the best empty position in which to
drop the next object from the cluster.
Three families of dropping strategies are introduced, namely, fitness-based
strategies, queue-based strategies, and priority queue-based strategies. Within
each family, the same general dropping technique will be used, but different
neighbourhoods and different exploration orders of the neighbourhoods are con-
sidered. For each geometric shape, a strategy is suggested, and visual output is
shown to verify the correctness.

3.1 Fitness-Based Strategies

Dropping strategies in this family follow the same general approach: while there
are still cells remaining in the cluster to be dropped, some neighbourhood around
the current cell is analysed using some fitness function. This function will return
an empty cell in the neighbourhood if one exists. The next object in the cluster
is dropped at the empty cell found, and the process is repeated until there are no
more objects to drop. The fitness-based strategies therefore depend on the neigh-
bourhood chosen, and the fitness function used. The size of the neighbourhood
directly affects how computationally expensive the particular dropping strategy
will be. To maintain the association with the LF model, the fitness function
used in these experiments is f (oi ), as it reflects the idea of clustering similar
cells together.
The three strategies discussed below are the basic drop, the Von Neumann
drop and the Moore drop. The basic drop simply returns any valid cell, while the
latter two strategies use a fitness function to determine the best cell for a drop,
using the Von Neumann or Moore neighbourhoods respectively. The results from
the fitness-based strategies are given in Fig. 2.

3.1.1 Basic Dropping Strategy This is the most basic of all the dropping
strategies. A comparative baseline is first established – if the fitness function
is applied to return a random empty cell in the neighbourhood, no discernible
shape should be generated. To force the simplest of shapes, a straight line can
be generated by exploring the neighbourhood in a fixed order and returning the
first empty cell. The high-level implementation is given in Algorithm 2.
Fig. 2(a),(b) demonstrate that the basic dropping strategy indeed achieves
the intended shapes. Note that the straight line strategy will always have a
 Shape Generation using Cellular Automata with Clustering 7

(a) Baseline: Basic (b) Basic drop (c) Von Neumann

drop, random clockwise, starting clockwise, starting
north north

(d) Von Neumann (e) Moore, clock- (f) Moore, clock-

anti-clockwise, wise, starting north wise, starting north-
starting west east

Fig. 2: Results of the fitness-based strategies

Algorithm 2: Basic drop method

/* ci the cluster being dropped */ p ←find empty neighbourhood cell, or null
if none;
while p 6= null and ci not empty do
drop next object in ci at p;
p ← find empty neighbourhood cell, or null if none;

single straight line in one direction (corresponding to the first choice in the
order), varying only when colliding with other clusters. Only the Von Neumann
neighbourhood was considered for the basic dropping strategy.

3.1.2 Von Neumann/Moore Dropping Strategy Given the thin rectan-

gular shape produced by the basic drop, is it possible to generate thicker rect-
angular shapes? We show that the fitness function f (oi ) can be used to produce
a neighbourhood-wide drop. As opposed to the basic drop, the fitness function
can be used to quantitatively identify the best cell for the next drop. Then cells
are preferred when located geometrically nearest to other dropped cells. Recall
that the LF fitness function for a cell ci is calculated by default over all the eight
cells surrounding ci .
In this strategy, the cell with the best fitness value in the Von Neumann (resp.
Moore) neighbourhood of the current cell is chosen to drop the next object in
the cluster. The best fitness value is defined as the highest object density f (oi ).
Note that if a second cell is found with the same fitness value as the current best
8 C. Zeeman, L. van Zijl

fit, the current best fit is kept. Since the fitness function must be evaluated for
all neighbours of all cells placed, this strategy is computationally more expensive
than the basic strategy.
These two examples illustrate how the order of the neighbourhood explo-
ration affects the shape of the cluster. In Fig. 2(c), the Von Neumann neigh-
bourhood is explored in the order [north, east, south, west]. This results in a
three-wide vertical line forming for each cluster. In contrast, reversing the or-
der to [west, south, east, north] provides three-wide horizontal lines instead (see
Fig. 2(d)).
The starting point in the exploration also plays a role. In Fig. 2(e), the
Moore neighbourhood is explored in a clockwise direction, starting in the north.
This produces thick horizontal clusters. In contrast, starting in the northeast
corner and exploring in a clockwise direction, results instead in diagonals in a
southeast orientation (see Fig. 2(f)). Thus, both the thickness of the cluster and
the orientation of the cluster formed is dependent on the exploration order of
the neighbourhood.

3.2 FIFO Queue-Based Strategies

In order to produce shapes that are not simply rectangular, one has to build
the shape incrementally, with knowledge of cells already used. For example, one
could form a diamond shape around a cell by dropping objects into the Von
Neumann neighbourhood of the cell at increasing distances. All strategies in
this family therefore make use of a first-in-first-out (FIFO) queue that keeps
track of all empty cells in neighbourhoods explored so far. At the start of the
drop, the initial cell is added to the queue. While there are still objects in the
cluster to drop, a new cell is popped from the top of the queue, an object is
dropped at this cell, and all empty cells in some neighbourhood around this new
cell is added to the queue. This process is continued until all the objects in the
cluster have been dropped, or the queue is empty.
Algorithm 3 shows a generic FIFO queue-based dropping strategy (adapted
from [1]). Note that both the queue-based and the priority queue-based strategy
implement a memory mechanism, somewhat reminiscent of higher order cellular
automata [2].
Since these dropping strategies do not use the fitness function when consid-
ering cells, all strategies in this family will often place cells directly adjacent to
another cluster. When sorting via clustering, this is undesirable — as such, if
the focus of the application is to sort data, it is better to use a fitness-based
strategy such as the Von Neumann drop.
The shape formed by a FIFO queue-based strategy depends entirely on which
neighbours are explored — and the order in which they are explored — when
adding cells to the queue. Four examples of queue-based dropping strategies are
given, with the results of each strategy shown in Fig. 3.

3.2.1 Diamond Dropping Strategy Since a Von Neumann neighbourhood

is by definition a diamond-shaped area, the diamond dropping strategy is straight-
 Shape Generation using Cellular Automata with Clustering 9

Algorithm 3: Generic FIFO queue drop method

/*ci the cluster being dropped*/
queue ← new Queue();
p ← position of the ant;
while p 6= null and ci still has objects to drop do
oj ← the next object to drop in ci ;
aP ← all empty positions in some neighbourhood of p;
queue.addAll(aP );
drop object oj at p;
/*find next empty position*/
if queue is empty then
/*incomplete drop*/
p ← null;
else
p ← queue.dequeue();

forward to implement. When adding new positions to the queue after dropping an
object, the Von Neumann neighbourhood (explored clockwise or anti-clockwise)
is used. Since a FIFO queue is being used, all positions in a Von Neumann neigh-
bourhood of radius one from the centre are considered, then radius two, and so
on. The final form is, therefore, that of a diamond. The first cell chosen will
determine the starting point of the shape, and the rotation direction will only
affect the shape if there are insufficient cells in the cluster to complete a full
layer of the diamond.

3.2.2 Square Dropping Strategy Again, producing a square using the

queue-based method is easy. The square dropping strategy is similar to the
diamond dropping strategy, except that the Moore neighbourhood is used when
adding new cells to the queue. This results in the shape forming a full Moore
neighbourhood of increasing radii around the centre (the starting point) of the
drop. Since the Moore neighbourhood is inherently square-shaped, this results
in a square forming around the starting point of the drop.

3.2.3 Pyramid Dropping Strategy Noting that a pyramid is half of a

diamond, a pyramid shape can be generated analogously to a diamond, both for
top-down and bottom-up pyramids.
In the top-down approach, the starting coordinates of the drop will be the
top of the pyramid. The neighbourhood used for exploration is chosen by picking
one cardinal direction in which the pyramid will be generated, and adding the
two adjacent diagonal directions. For example, [south, southeast, southwest] will
cause a pyramid to form downwards, with the top being at the coordinates of the
drop. Note that the cardinal direction should always be first in the exploration
order.
10 C. Zeeman, L. van Zijl

(a) Diamond drop (b) Square drop (c) Bottom-up pyra-

mid drop

(d) Triangle drop, (e) Circle drop

north-east

Fig. 3: Results of the queue-based and priority queue-based strategies

In the bottom-up approach, the pyramid will form such that the starting
coordinates of the drop will be the centre of the base of the pyramid. This is
achieved by letting the neighbourhood used for exploration consist of any three
cardinal directions. Exactly one of the three directions will be directly adjacent
to both of the other directions: this direction denotes the direction in which
the pyramid will grow. For example, if the neighbourhood [east, north, west] is
chosen, then only north is adjacent to both east and west, so the pyramid will
form with the base growing in an east-west direction, and the top directly north
of the starting point.

3.2.4 Triangle Dropping Strategy To generate right-angled triangles, the

right-angled corner of the triangle is placed at the starting coordinate of the drop,
and two cardinal directions are chosen. The direction of the two sides projecting
from that corner depends on which directions are chosen. The general pattern for
this dropping strategy is to pick the two adjacent sides surrounding the diagonal
in which the triangle should grow. For example, a neighbourhood [north,east]
will form a triangle to the northeast, while [east,south] will form a triangle to
the southeast.
Note that the memory usage of all the queue-based strategies are identical,
as each strategy builds the queue, and the shape is determined by the order in
which the objects are added to the queue. The upper bound on the queue size
is the number of objects on the grid. This upper bound can be reached if all the
objects on the grid have the same colour.
 Shape Generation using Cellular Automata with Clustering 11

3.3 Priority Queue-Based Strategies

This family of dropping strategies follows the same general approach as the FIFO
queue-based strategies, but uses a priority queue instead. A priority is associated
with each item in the priority queue such that the item with the highest priority
is at the front of the queue. This allows more complex features to be incorporated
into the dropping strategy. The generic priority queue-based dropping strategy
is given in Algorithm 4, and the use of the priority queue is demonstrated in the
circle dropping strategy.

Algorithm 4: Generic priority queue drop method

priorityQueue ← new PriorityQueue();
start ← coordinates of the starting point of the drop;
p ← position of the ant;
while p 6= null and ci still has objects to drop do
oj ← the next object to drop in ci ;
priorities, positions ← all empty positions in some neighbourhood of p,
where the priorities are generated by f (start, positions);
priorityQueue.addAll(priorities, positions);
drop object oj at p;
/*find next empty position*/
if priorityQueue is empty then
/*incomplete drop*/
p ← null;
else
p ← priorityQueue.dequeue();

3.3.1 Circle Dropping Strategy As a geometrical shape, a circle is formed

as a structure of a certain radius around a centre point. Therefore, the starting
point of the drop is chosen to be the centre of the circle, and cells are dropped
around the centre in order
√ of distance. This causes a filled circle to form of
radius one, then radius 2, and so on, until no more cells need to be dropped.
See Fig. 3(e).
The priority queue is used to store the coordinates of the starting point.
For every coordinate added to the queue, the priority is the distance from the
starting point to this new coordinate. When taking the next coordinate from the
priority queue, the algorithm uses the coordinate that has the lowest distance
from the starting point. The periodic boundary of the CCA has to be taken into
account when calculating euclidian distances that span the boundary.
In summary, we proposed different strategies for the generation of different
shapes. Rectangular directional shapes can be generated by the fitness-based
strategies, and the size of the neighbourhood influences the computation cost.
12 C. Zeeman, L. van Zijl

More complex shapes, such as squares or triangles, require the use of queue-based
strategies. Here, the computational cost is less than that of the fitness-based
strategies, at the cost of a increased memory requirement.

4 Conclusion
Geometric shape generation was successfully performed for CCA based on an
ant sorting model. It was shown that different dropping strategies, with different
exploration orders, can be used to drop clusters of different shapes. Fitness-
based dropping strategies can be more expensive in terms of execution time
depending on the given neighbourhood, whilst queue-based and priority-queue-
based strategies are computationally less expensive, but requires extra memory
usage for the queue.
The geometrical forms generated by the strategies discussed in this article
are relatively simple shapes. An investigation into other dropping strategies,
that generate more complex geometrical forms, is appropriate. As a first step,
the effect of changing the fitness function to operate over a whole cluster, rather
than over a single cell, should be investigated. Another avenue of investigation
is to extend this work to generate three-dimensional shapes.

References
1. Adams, R., van Zijl, L.: Ant sorting based on cellular automata with clustering. In:
Proceedings of the Annual Conference of the South African Institute of Computer
Scientists and Information Technologists. p. 29–38. SAICSIT ’18, Association for
Computing Machinery, New York, NY, USA (2018)
2. Baas, N.A., Helvik, T.: Higher order cellular automata. Advances in Complex Sys-
tems 8, 169–192 (2005)
3. Chavoya, A., Duthen, Y.: A cell pattern generation model based on an extended
artificial regulatory network. Biosystems 94(1-2), 95–101 (2008)
4. Delorme, M., Mazoyer, J., Tougne, L.: Discrete parabolas and circles on 2D cellular
automata. Theoretical Computer Science 218(2), 347–417 (1999)
5. Deutsch, A., Nava-Sedeño, J.M., Syga, S., Hatzikirou, H.: BIO-LGCA: a cellular
automaton modelling class for analysing collective cell migration. PLOS Compu-
tational Biology 17(6), e1009066 (2021)
6. Dorigo, M., Di Caro, G., Stützle, T.: Special issue on Ant Algorithms. Future
Generation Computer Systems 16(8), 851–956 (2000)
7. Lumer, E., Faieta, B.: Diversity and adaptation in populations of clustering ants.
In: Proceedings of the Third International Conference on Simulation of Adaptive
Behaviour: From Animals to Animats. p. 499–508. MIT Press, Cambridge, MA,
USA (1994)
8. Macedo, Y.P., Chaimowicz, L.: Improving procedural 2D map generation based
on multi-layered cellular automata and Hilbert curves. In: 2017 16th Brazilian
Symposium on Computer Games and Digital Entertainment. pp. 116–125. IEEE
(2017)
9. Van Zijl, L., Smal, E.: Cellular automata with cell clustering. In: Proceedings of
AUTOMATA 2008: Theory and Application of Cellular Automata. pp. 425–440.
Luniver Press (2008)
 Shape Generation using Cellular Automata with Clustering 13

10. Van Zijl, L.: Clustering in 1D binary elementary cellular automata. In: Proceedings
of the 2015 Annual Research Conference on South African Institute of Computer
Scientists and Information Technologists. pp. 1–7. SAICSIT ’15, Association for
Computing Machinery, New York, NY, USA (2015)
11. Wolfram, S.: Theory and applications of cellular automata, vol. 1. World Scientific
Singapore (1986)
12. Zhang, D., Choi, C., Kim, J., Kim, Y.M.: Learning to generate 3D
shapes with generative cellular automata. In: 9th International Confer-
ence on Learning Representations, ICLR, poster presentation (March 2021),
https://arxiv.org/pdf/2103.04130.pdf