# Student Post: Programming Tilings with Escher

## Introduction

This post assumes that you have downloaded the KoebeLib repository  and are using IntelliJ IDEA.

Escher is a domain specific language that was created to allow users to efficiently define and describe combinatorial subdivision rules and perform the subdivision. Today I will be showing you how to write a subdivision tiling program using Escher. Our tiling of choice for this tutorial is the well known Chair Tile (Figure 1).

Figure 1: The subdivision iterations of the geometric Chair Tile. [1]

## Writing the Program

Figure 2: Sample code for a Chair Tile subdivision program in Escher

The first step in writing our subdivision program is to define all of the tiles that will be used (prototiles). Define a prototile using the keyword TILETYPE followed by an identifier for our tile and the number of vertices enclosed in {}. Note that the vertices created for a tile are indexed 0-N and connected sequentially into a cycle with N being connected to 1 and N-1. For our example we only have one prototile and it is defined on line 1.
`TILETYPE chair {8};`

Next, each prototile that is defined needs to have an accompanying set of subdivision rules. To define the subdivision rules for a specific prototile use the keyword SUBDIVISION followed by the name of the prototile. All of the subdivision rules need to be enclosed in a block designated by the {}. For our example we only need subdivision rules for the chair tile and they are defined in lines 2-21.
`SUBDIVISION chair { INSERT RULES HERE };`

Within a subdivision rule definition we can perform three main actions: splitting preexisting edges to created new vertices, creating new unconnected vertices, and specifying the child tiles. Creating a new vertex with the split function requires the keyword VERTEX followed by an identifier for the vertex, and equal sign, and the split function with the appropriate parameters. The three parameters for the split function are the origin and destination vertices for the desired edge and the number of edges you want to split that edge into. Note that for splits with edge counts larger than 2 you need to specify and identifier for each vertex that will be created when splitting the edge. For our example we split all of the edges on our Chair in lines 4-11. New unconnected vertices are created in lines 12-16.
```VERTEX a = split(chair.vertex[0], chair.vertex[1], 2); VERTEX b = split(chair.vertex[1], chair.vertex[2], 2); VERTEX c = split(chair.vertex[2], chair.vertex[3], 2); VERTEX d = split(chair.vertex[3], chair.vertex[4], 2); VERTEX e = split(chair.vertex[4], chair.vertex[5], 2); VERTEX f = split(chair.vertex[5], chair.vertex[6], 2); VERTEX g = split(chair.vertex[6], chair.vertex[7], 2); VERTEX h = split(chair.vertex[7], chair.vertex[0], 2); VERTEX i; VERTEX j; VERTEX k; VERTEX l; VERTEX m;```

The children in a set of subdivision rules are the resulting prototiles that are created by connecting newly created and existing vertices within the parent tile. To create a child rule use the keyword CHILD followed by and identifier for the child, an equal sign, and information about the resulting child tile: the tiletype followed by all of the vertices in counter-clockwise order encased in ([]). For our example we create four children of the chair tiletype in lines 17-20.
```CHILD c1 = chair([chair.vertex[0], a, chair.vertex[1], j, i, m, chair.vertex[7], h]); CHILD c2 = chair([chair.vertex[2], c, chair.vertex[3], d, k, j, chair.vertex[1], b]); CHILD c3 = chair([i, j, k, d, chair.vertex[4], e, l, m]); CHILD c4 = chair([chair.vertex[6], g, chair.vertex[7], m, l, e, chair.vertex[5], f]);```

Finally we want to tell the program to execute the tiling. In order to do that we use the tile function and provide it with two parameters: the initial prototile and the number of subdivision iterations. Four our example we start with a chair tile and subdivide three times on line 22.
`tile( chair, 3 );`

Congratulations, you have successfully written your first Escher program. Save the file as chair.es and be sure to remember where you saved it.

## Running the Program

In order to run the program locate the EscherDriver.kt file at KoebeLib/src/tiling/language/algorithms/EscherDriver.kt in the IntelliJ IDE and edit the run configurations. We need to add the full path of the Escher program file that we just saved into the Program arguments box. Now we can run the EscherDriver on our program by clicking the green triangle in the top right of the IDE. Running the driver will produce three files in the main KoebeLib directory: config, verts, and edges. These files will be used to visualize the tiling created by our program.

## Visualizing the Results

In order to visualize the tiling we have created we will be using a python script that has been included in KoebeLib. Open a terminal and navigate to KoebeLib/src/tiling/language/algorithms/. Run the provided python script by typing `python planarDraw.py` this should display the tiling (Figure 3). This figure can be saved through the options at the bottom of the graph.

Figure 3: A graph of the Chair tiling after three iterations of subdivisions.

## Bibliography

[1] Luis Blackaller, Piles of Tiles, http://black.mitplw.com/tiles/aperiodic.html