The publication in 1859 of Charles Darwin’s Theory of Evolution unified the theories of biological sciences as it explains the diversity of life. In his 1859 book On the Origin of Species, he established that all living species have descended over time from common ancestors. In recent years, key concepts of his theory have propagated to reach many spheres of research beside biology. In this project, the aim is to apply the fundamental ideas of evolution, inheritance and development in an exercise of genetic algorithm and understand how principles of inheritance and natural selection can be used in the generation of geometric forms.



Family tree of all five bred populations originating from a single cube


The Pseudo-Code

The first part of the pseudo-code establishes the developmental approach for this sequence and is constituted as follows:
A primary list with all the individuals of a population is first placed into the sequence as data containing multiple layers of written information. What follows is the creation of nested data such as the object identification number, its genome and the ratio associated with it. This allows sorting the main list according to the nested information, and to extract the individuals that score for the lowest fitness ratio (favorable) of object volume to bounding box volume. These fittest individual are then bred to produce a new generation. Again, the fittest ones (the ones with the lowest numerical ratio) are chosen. The selected individuals have their genomes analyzed and compared. After iterating the process 3 times, we note the following:

1- The longer the sequence of the genes is, the larger the objects are.
2- The genes that are combined in the order of “Scale” then “Copy” then “Rotate” produce the large pointed forms.
3- The breeding of the fittest produce children with a hierarchy in size but also in typology.


As noted, the resulting individuals produce children that could be classified into 2 main typology classes each with different sizes: we named them the “compact” individuals and the “spiky” individuals. Each of these 2 classes has different individuals within it, all of which share a certain degree of resemblance. For instance, the spiky individuals in population 8 (of sequence 2) have different sizes and forms, but all of them can be traced to a common parent and all of them share the same typology. One could argue that they all look alike, in contrast to the compact ones which look a bit different. This denotes the capability of the engine to produce non-identical, yet typologically similar individuals, all due to a random seed in the script that allows for a random recombination of the genes while preserving their overall sequence.



The second part of the pseudo-code is the main engine for the growth of the body rather its constituents. It derives from the iterative process and perpetual feedback between growth and self-evaluation, and constitutes therefore the evolutionary approach of the sequence. This part incorporates the first part for the development of individuals, however its use comes from the fact that it is structured in a way to judge whether the growth of the body from the multiplication of individuals should continue towards an overall compact form or to switch if needed to for a less compact and a more spiky shape in certain areas. The latter is achieved by using an if/else statement inside the loop of the iterative engine such as, at the end of each multiplication phase, the body evaluates itself and outputs a numerical value representing its new ratio to influence the outcome of the multiplication process. The multiplication phase is not a simple array of the individual; it consists of copying the individual and relocating its copy to the farthest point of the original. All in all, this second part of the pseudo-code allows for more control over the overall growth of the body, and as the body develops, it provides more differentiation in the body parts.




The Script

The writing of the script consists of encoding all the information needed into the evolutionary and developmental algorithms. The script is structured in many modules, all of which can be imported in one single file that executes them. This part of the script consists of encoding the genes, which requires listing them as string objects containing only letters in between quotation-marks (example “S3x”). The string “S3x” has absolutely no tangible meaning or value until it is defined in a function called S3x of specific parameters. It will eventually be called later in as the debugger falls on the letters “S3x” in the genome. Any function in the script needs to be determined by a number of variables or parameters. If we take S3x as an example, the minimum necessary parameters needed for the scaling would be an object and an origin for scaling.



The other data such as the factor of scaling are not variables and could be nested inside the function as constants since we know what that gene specifically does, which is scaling objects 3 times in x. The parameters do not have to be all specified at each recursion; they are instead inherited from the previous step and automatically updated as the individual gets modified.

1- List the genes as string objects containing multiple classes, tuples and lists
2- Created nested tuples for the distributed criteria and sort the external list according to the nested data
3- Create an empty list for the genome for a later insertion of genes based on the fitness criteria and kill strategy
4- Assign a Rhino-function to each gene (using the modules “rhinoscriptsyntax” and/or “Rhino”) by encoding data into functions
5- Extend the previously empty list of the genome based on our fitness criteria and kill strategy
6- Call each gene within the genome in order of their sequence (using the for-loop and the if statement)
7- Affect the primitives in the scene with the genome based on their location within the body plan
8- Re-inform the selection of genes as the body moves form embryo, through polarization and orientation and subdivision into a “fully evolved” physical entity (using a nested for-loop)





A portion of the Python written code for generating the geometry




Architectural Association
Emergent Technologies & Design
Emergence

2012

© 2023 Lemire Abdel Halim Chehab. All Rights Reserved.