**Letterform Lattices: A Case Study in Mass Customization**

Tim McCormick, v. 1.3 (status: draft), June 26, 2010

### 1) Content / Summary

1. Background: Li-Rong Liao’s IScreen project

In the IScreen project, Liao (2010) created a modular, Chinese-style *[how Chinese?]* lattice out of stylized, joined, and rotated letterforms from the letters of her name. Liao’s design uses a 3-level modularity, in which four letterforms combine into one unit, then 4 of these units combine into the main modular unit, and then the screen is made from these main units (alternating filled and empty spaces)). The effect is striking, but the underlying 3-level assemblage method is relatively complex.

2. Background: mass customization

- The core interest in this investigation is
*mass customization:*combining mass-production efficiency, with customization of the product for individual consumers. - An elegant mass customization could be achieved if Liao’s design method could automatically produce screens out of any letter combinations.

- To make physical screens out of arbitrary letters, a major complexity is that the resulting patterns
*must hold together as a physical object.*

- Goals:

- make a process for designing, not just one design
- Goal: very rapid prototyping
- Goal: Produce wide variety of versions, e.g. to show clients
**Goal: Allow customers to personalize the product (mass customization)**

- develop algorithms that can apply to other projects
- possibly, generalize the design method and tools for use by others (e.g. on the model of Open Source)

- Pick something that produces the desired tiling or lattice. (note: tiling is where shapes fill the plane completely; lattices have open space in or between modules, and the term is often used to describe patterned window screens.
- Represent it as a matrix of n x m pixels (Matrix A base unit matrix).

- Chose / design an alphabet of low pixel resolution and maximum “joinability.”
- Also, for each letter specify a series of pixels to progressively add, in order to increase joinability (“Fix Pixels”).
- Specify letters in a matrix p x q (Matrix B letter matrix)

map the ‘B’ Matrices onto Matrix A.

6. Find cases where adjoining letters don’t join

- Manually — create in advance a table of what letter combinations do not join. Similar to notion of “kerning pairs” in typography

- or analyze by an algorithm that checks if there is at least one shared edge between the pixels of letters A & B and B & C.

- For any non-joins, add a “fix pixel” to the first letter, then run the join-detection test again; iterate until join is verified

7. *Fix* cases where adjoining letters don’t join.

- For any non-joins, add a “fix pixel” to the first letter, then run the join-detection test again; iterate until join is verified.

The Master Matrix represents the main module, i.e. what will become the entire finished object or tile. Copy the [typically four] ‘A’ Matrices into this matrix.

9. Analyze and alter cases where adjoining ‘A’ Matrixes don’t join in the Master Matrix.

use the same procedure as in 6) and 7).

10. Output and fabrication

From Master Matrix, generate a SVG (Scalable Vector Graphic) XML file. This can be used to output the matrix, or to produce physical objects (e.g. using a laser cutter).

11. Conclusion

The steps where the process guesses which aditional pixels might be needed, is probably where our process automation would be weakest,

The investigation so far suggests that it may be possible to automate large parts of a design customization, but it may be extremely difficult to automate every part. Even in the controlled domain of the lattice design in this study, it takes great effort to algorithmically simulate what human design judgment would do.

12. Possible future work

- Interlocking forms: make the main modules interlink in the way Liao’s do. This happens with certain letter combinations at the start of the 3-letter combination, but it could be made to happen always by adding an pseudo letter to the start of each 3-letter combination, to act as the “hook”.

- Handle different base forms, e.g. 2 or 3-letter combinations in which all letters are vertical.
- Overlapping letterforms: where two letters meet, make the result 1-line width thick rather than 2.

__________________________________________________

### 1. Background

This project is inspired by and extends IScreen, a 2010 project by Li-Rong (Lisa) Liao, a student in the graduate Industrial Design program at Pratt Institute. (portfolio, personal site). IScreen is based on a method for making a modular lattice — which has the appearance of a traditional Chinese lattice — based on the abstracted characters of her English name, “LISA”. Four or eight of these modules can be combined in a ring to form a larger module; these modules fit together, forming a pattern that can be extended indefinitely to form a large screen or wall decoration. See photo below and Liao”s blog post for more explanation.

Liao suggested a further development of the project, in which “In the future, users can go on line and order customized screens with unique graphics made from their desired characters.”

Extension of the ‘LISA’ lattice process

I investigated an idea, as suggested by Liao : the question of **how to automate the design and production of lattices based on arbitrary letter combinations. **So far, I am considering combinations of three letters, i.e. typical personal initials, but the method could be extended to more complicated cases (and might be better justified by those cases, in fact). The three letters are placed together as in Figure a) below, i and ii and iii, and they must have enough edges in common that the letters will “join” and hold the lattice together. Given the input of three letters, the desired output is a vector graphic that can be used for various purposes, including fabrication of a physical object e.g. with a laser cutter

** Automating Design?
**

You could say that the problem is whether an algorithmic (i.e., automatic) method can carry out this design task that seems to require human design thinking. That is, how to choose and arrange letterforms such that any combination of three letters in the specified arrangement will join. Advantages for such an automatic method include the following:

- it can be pplied to a much larger set of cases,
- it can perhaps generate all valid variations of a design much faster than a person could do it
- it can iscovering valid productions missed by human designers.

Which means, a working method could be used for **rapid prototyping**, e.g. quickly seeing the lattice produced by a given set of letters. In the commercial application envisioned, the buyer might wish to preview various options such as different letter combinations and different configurations (e.g. lattice made by vertical-vertical-vertical letters rather than vertical-horizontal-vertical, or lattice made by 8-part rather than 4-part join of the base module.

To put the problem in perspective, consider that the number of possible three-letter groups is 26 x 26 x 26 = 17,576 combinations.

Let’s say we’re combining letters as in figure a) below. The number of possible joins between letters in positions i. and ii. is 26 x 26 = 676, and there are an equal number of possible joins between letters in positions ii. and iii. So the number of letter-pair boundaries =

2 x (26 x 26) = 1352.

Clearly it is a difficult task for a human to consider all possible letter-pair boundaries and determine in each case whether the letters will join correctly — a join being necessary for the lattice to hold together.

### 2. Choosing a base form.

To explore the fitting together of letterforms, a reasonable simplification is to fit all forms into a standard unit, with that unit being one that assembles into a desired lattice pattern. The above illustrations shows a number of ways that basically rectangular forms can be joined into larger units, with a mixture of positive and negative space — which in turn creates the postive/negative quality of a lattice screen.

Liao used a three-part form consisting of: a vertical letter, then two letters horizontal, then another vertical letter (roughly the form a) above). The middle section is less wide than the vertical letters are tall, so there is a indentation in the middle section of the form.

*(Note that this indentation, it turns out, can range from zero up to half of the form’s shorter side, without preventing the form from being fitted together as shown in b) and c) above).*

Using the case where indentation is half of the rectangle short side, we get the abstracted form above. Overall, this form is twice as wide as it is tall, and it can be decomposed into three equally-sized rectangles, each twice as high as they are wide, as shown in a) i-iii.

I chose to use this form because its 3 part parts are suitable for fitting 3-letter initials. (See for example the combination of ‘A’, ‘B’, and ‘C’ in section 3). However, I believe the process described below can be generalized to different base forms and tiling methods, and I will consider this generalization as a future goal for the project.

### 3. Letterforms

Given the choice of forms above, we need component letterforms which meet these requirements:

- Make letters twice as high as they are wide
- Maximize the ease of joining contiguous letters, by filling the edges of their forms as much as possible
- Are simple enough to be allow automated calculation of joins, non-joins, and edges; and eventually, fabrication
- Minimize the use of diagonals [why?]

These requirements suggest a block alphabet. So I’ve drawn an alphabet in which each letter is described by 3 x 6 = 18 pixels, based partly on the 3×3 typeface designed by Anders de Flon:

**3×3 typeface**:

**my Block1 font:**

these letter forms are all made from 3×6 pixels. Therefore they fit into the base form below, which can be decomposed into three 3×6 rectangles:

Below is an example of three letters, ‘A’, ‘B’, ‘C’, arranged so they would fit into the base form:

### 4. Replacement Tables

Some letter combinations do not join when they are adjacent. This is recorded in a *replacement table *that lists non-joining letter pairs. Below is a preliminary list of non-joining letter pairs:

a) on border between first and second letters in group:

B – L

D-L

F-L

P-*

T-*

Y-*

J-J

G-J

F-J

C-J

B-J

b) on border between second and third letters in group:

*-T

*Y

T-I

T-S

T-Z

### 4. Recording the letterform pixels and edges in letterform arrays

We produce a *letters array, *which as three columns

- a unique ID
- a descriptor for the letter being described — e.g. ‘A’, ‘A horizontal’
- an array,
*letterform array,*described below

- the regular alphabet
- the alphabet of letters turned 90 degrees counter-clockwise
- any letterforms created to solve joining problems

Each element of the letters array is itself an array: a *letterform array. *

Each letterform array is a 6×6 (to handle both vertical 3×6 letters and horizontal 6×3 letters). Each element of a letterform array contains a list or values. The next values represent the state of the each pixel (possible values are listed below); the next 6 values of the list represent the pixels’ edge values. Total so far = 7 values per array element. The pixel state values are:

- blank
- full
- upwards diagonal, full above
- upwards diagonal, full below
- downwards diagonal, full above
- downwards diagonal, full below

*Note, a statement of which of the above descriptors applies to each pixel is sufficient to fully describe a given letterform.*

To describe the pixels’ edges, a value the 6 possible edge values for the pixel, stored in the corresponding array element, are the following:

value 1: top edge to be cut (yes/no)

value 2: right edge to be cut (yes/no)

value 3: bottom edge to be cut (yes/no)

value 4: left edge to be cut (yes/no)

value 5: up-diagonal edge to be cut (yes/no)

value 6: down-diagonal edge to be cut (yes/no)

This adds 6 values to the list associated with a given array element, bringing the total to 13.

The edge values can either be manually derived, or produced automatically by going through each pixel that is non-blank, and set each edge value to true unless there is an adjacent full pixel, or a diagonal pixel with adjacent edge.

.

### 5. Generating the main array

These values are stored in the main array, which is expanded so that each element has a list of 8 values — 7 values of which are yes/no for the set of edges.

Next we create a 12×6 “main array” and initialize to zeros. We copy the individual letter arrays into the appropriate positions in main array. Below is a representation of the main array, with highlighting on the squares involved in the join between two adjacent letters.

6. Checking and creating letter joins

A. [ Look-up method ]:

For i-ii and ii-iii letter pairs, look up in replacement table to see if any alternate letterforms should be used. If so, copy letterform values into main array in the appropriate position.

B. [ Algorithmic method, which can also be used to check look-up method results ]:

Check the array elements corresponding to the pixels adjoining the boundaries between letterform a and b, and letterform b and c: If no joining squares are found for a given boundary,

- go to the replacement table, search for entries beginning with letter 1
- loop through entries, and for each entry that matches, do the following:
- copy letterform into main array, in the position formerly occupied by the letter being replaced
- perform edge check
- if non-joins are found, repeat this procedure.

If facing squares share an edge, remove the edge values from the two letterforms, in the main array.

So, now we should have 12×6 array that specifies the cuts needed to produce the whole piece.

7. Checking joins for 4-module composition

The above discussion has concerned how 3 letterforms can compose into a rectangular form such as d. in the diagram above. However, in order to achieve the 4-way interlocking of the 3-part forms, it is also necessary that a 3-part form such as a) above, which has been rotated 90 degrees clockwise and fitted in to the indentation in d), also has 1 or more joins.

We check for joins *between* forms such as a) and d) in the same way we checked for joins *between the letterforms* comprising a) and d). Each boundary pixel in d) is checked to see if it abuts a pixel in a), and if so, there is a join. As long as there is one join, the two forms can be considered adequately (if minimally) joined.

### 8. Visualization

For visualization before or instead of fabrication, we can use the pixel form values in the main array. Loop through all elements of the main array, and render the specified forms.

9. Output and fabrication:

a) For fabrication, take the main array describing all edges to be cut, and from this generate a SVG XML file.

b) Convert to whatever format needed by laser cutter. Cut and punch out tiles

### 10. Future work

a) create interlocking forms like Lisa’s:

The above process creates interlocking tiles if the initial letter if one of the following:

A, H, K, M, N, P, R, T (usually).

For the rest of the letters, the form can be made interlocking if an extension is added to the front of the first letter like below.

The addition of the interlock extension may be possible by adding the extension as a 4th letter. The main array would have to be extended to 14×6.

b) handle different base forms, e.g. 2 or 3-letter combinations in which all three letters are vertical.

Possibly, this could be done by

- changing the main array to 9×6
- creating a new replacement table. or
- using edge-derivation method from section 7) above.

c) overlapping letterforms:

in the scheme as described, letterforms join by adjacency: that is, two 1-pixel lines join to form a 2-pixel-thick joint line. However, this leads to a particular and possible undesired effect in the final lattice: some lines/areas are significantly heavier than other, i.e. form heavy masses.

.

.

.

.

.

.

.

.

.