Repeating Hyperbolic Pattern Algorithms Special Cases

Transcription

1 Repeating Hyperbolic Pattern Algorithms Special Cases Douglas Dunham Department of Computer Science University of Minnesota, Duluth Duluth, MN , USA Web Site: ddunham/ 1

2 Outline 1. History 2. A Repeating hyperbolic pattern algorithm based on regular tessellations 3. A Repeating hyperbolic pattern algorithm based on nonregular tessellations 4. Future work 2

3 1. History 1. Pre-Escher 2. Escher s patterns 3. Post-Escher = Dunham, Ferguson, Sazdanovic, etc. 3

4 Triangle group (7,3,2) tessellation Originally in Vorlesungen über die Theorie der elliptischen Modulfunctionen F. Klein and R. Fricke,

5 H.S.M. Coseter s Figure 7 in Crystal Symmetry and Its Generalizations Trans. Royal Soc. of Canada,

6 M.C. Escher s Circle Limit Patterns Circle Limit I 6

7 Circle Limit II 7

8 Circle Limit III 8

9 Circle Limit IV 9

10 2. Generation of Repeating Hyperbolic Patterns Following Escher, we use the Poincaré disk model of hyperbolic geometry. 10

11 The Pattern Generation Process Consists of two steps: 1. Design the basic subpattern or motif done by a hyperbolic drawing program. 2. Transform copies of the motif about the hyperbolic plane: replication 11

12 Repeating Patterns A repeating pattern is composed of congruent copies of the motif. A motif for Circle Limit I. 12

13 The Regular Tessellations {p, q} Escher based his four Circle Limit patterns (and many of his Euclidean and spherical patterns) on regular tessellations. The regular tessellation {p, q} is a tiling composed of regular p-sided polygons, or p-gons meeting q at each vertex. It is necessary that (p 2)(q 2) > 4 for the tessellation to be hyperbolic. If (p 2)(q 2) = 4 or (p 2)(q 2) < 4 the tessellation is Euclidean or spherical respectively. 13

14 The Regular Tessellation {6, 4} 14

15 A Table of the Regular Tessellations * * * * * * * * * 10 * * * * * * * * * 9 * * * * * * * * * 8 * * * * * * * * * 7 * * * * * * * * * q 6 * * * * * * * * 5 * * * * * * * * 4 * * * * * * * 3 * * * * * p - Euclidean tessellations - spherical tessellations * - hyperbolic tessellations 15

16 Replicating the Pattern In order to reduce the number of transformations and to simplify the replication process, we form the p-gon pattern from all the copies of the motif touching the center of the bounding circle. Thus to replicate the pattern, we need only apply transformations to the p-gon pattern rather than to each individual motif. Some parts of the p-gon pattern may protrude from the enclosing p-gon, as long as there are corresponding indentations, so that the final pattern will fit together like a jigsaw puzzle. The p-gon pattern is often called the translation unit for repeating Euclidean patterns. 16

17 The p-gon pattern for Circle Limit I 17

18 Layers of p-gons We note that the p-gons of a {p, q} tessellation are arranged in layers as follows: The first layer is just the central p-gon. The k + 1 st layer consists of all p-gons sharing and edge or a vertex with a p-gon in the k th layer (and no previous layers). Theoretically a repeating hyperbolic pattern has an infinite number of layers, however if we only replicate a small number of layers, this is usually enough to appear to fill the bounding circle to our Euclidean eyes. 18

19 The Regular Tessellation {6, 4} Revisited To show the layer structure and exposure of p-gons. 19

20 Exposure of a p-gon We also define the exposure of a p-gon in terms of the number of edges it has in common with the next layer. A p-gon has minimum exposure if it has the fewest edges in common with the next layer, and thus shares an edge with the previous layer. A p-gon has maximum exposure if it has the most edges in common with the next layer, and thus only shares a vertex with the previous layer. In the pseudo-code, we abbreviate these values as MAX EXP and MIN EXP respectively. 20

21 The Replication Algorithm The replication algorithm consists of two parts: 1. A top-level driver routine replicate() that draws the first layer, and calls a second routine, recursiverep(), to draw the rest of the layers. 2. A routine recursiverep() that recursively draws the rest of the desired number of layers. A tiling pattern is determined by how the p-gon pattern is transformed across p-gon edges. These transformations are in the array edgetran[] 21

22 The Top-level Routine replicate() Replicate ( motif ) { drawpgon ( motif, IDENT ) ; // Draw central p-gon for ( i = 1 to p ) { // Iterate over each vertex qtran = edgetran[i-1] for ( j = 1 to q-2 ) { // Iterate about a vertex exposure = (j == 1)? MIN_EXP : MAX_EXP ; recursiverep ( motif, qtran, 2, exposure ) ; qtran = addtotran ( qtran, -1 ) ; } } } The function addtotran() is described next. 22

23 The Function addtotran() Transformations contain a matrix, the orientation, and an index, pposition, of the edge across which the last transformation was made (edgetran[i].pposition is the edge matched with edge i in the tiling). Here is addtotran() addtotran ( tran, shift ) { if ( shift % p == 0 ) return tran ; else return computetran ( tran, shift ) ; } where computetran() is: computetran ( tran, shift ) { newedge = (tran.pposition + tran.orientation * shift) % p ; return tranmult(tran, edgetran[newedge]) ; } and where tranmult ( t1, t2 ) multiplies the matrices and orientations, sets the pposition to t2.pposition, and returns the result. 23

24 The Routine recursiverep() recursiverep ( motif, initialtran, layer, exposure ) { drawpgon ( motif, initialtran ) ; // Draw p-gon pattern if ( layer < maxlayers ) { // If any more layers pshift = ( exposure == MIN_EXP )? 1 : 0 ; verticestodo = ( exposure == MIN_EXP )? p-3 : p-2 ; for ( i = 1 to verticestodo ) { // Iterate over vertices ptran = computetran ( initialtran, pshift ) ; qskip = ( i == 1 )? -1 : 0 ; qtran = addtotran ( ptran, qskip ) ; pgonstodo = ( i == 1 )? q-3 : q-2 ; } } } for ( j = 1 to pgonstodo ) { // Iterate about a vertex newexposure = ( i == 1 )? MIN_EXP : MAX_EXP ; recursiverep(motif, qtran, layer+1, newexposure); qtran = addtotran ( qtran, -1 ) ; } pshift = (pshift + 1) % p ; // Advance to next vertex 24

25 Special Cases The algorithm above works for p > 3 and q > 3. If p = 3 or q = 3, the same algorithm works, but with different values of pshift, verticestodo, qskip, etc. 25

26 The case p = 3 In replicate() the calculation of exposure in the inner loop is the same as the general case. In recursiverep(): pshift = 1 regardless of exposure. verticestodo = 1 regardless of exposure. qskip pgonstodo MAX EXP. newexposure is -1 for MIN EXP and 0 for MAX EXP. is q - 4 for MIN EXP and q - 3 for is the same as the general case. In both replicate() and recursiverep() at the last iteration of the inner loop, the call to recursiverep() is replaced by a non-recursive call to drawpgon(). 26

27 The case q = 3 In replicate(), exposure = MAX EXP in the inner loop regardless of whether it is the first iteration or not. In recursiverep(): pshift is 3 for MIN EXP and 2 for MAX EXP. verticestodo is p - 5 for MIN EXP and p - 4 for MAX EXP. qskip = 0 pgonstodo = 1 newexposure i > 1. for all cases. for all cases. is MIN EXP if i = 1 and MAX EXP if 27

28 Some New Hyperbolic Patterns Escher s Euclidean Notebook Drawing 20, based on the {4, 4} tessellation. 28

29 Escher s Spherical Fish Pattern Based on {4, 3} 29

30 A Hyperbolic Fish Pattern Based on {4, 5} 30

31 Escher s Euclidean Notebook Drawing 45, based on the {4, 4} tessellation. 31

32 Escher s Spherical Heaven and Hell Based on {4, 3} 32

33 A Hyperbolic Heaven and Hell Pattern Based on {4, 5} 33

34 Escher s Euclidean Notebook Drawing 70, based on the {6, 3} tessellation. 34

35 A Hyperbolic Butterfly Pattern Based on {7, 3} 35

36 3. Pattens Based on Non-Regular Polygon Tessellations A non-regular p-sided polygon with q 1,q 2,...,q p copies around the respective vertices forms a hyperbolic tessellation provided p 1 < p i=1 q i 2 1 (so the interior angle at the i th vertex is 2π/q i ). This tessellation is denoted {p;q 1,q 2,...,q p } The pattern drawing algorithm is similar to the case for regular tessellations: a non-recursive driver, replicate() calls a recursive routine replicatemotif(). Unfortunately this algorithm draws multiple copies of the motif if p = 3 or if any of the q i = 3. There are only a few duplications near the center, but the number of them grows exponentially in the number of layers. 36

37 A {4; 6, 3, 6, 4} Polygon Tessellation 37

38 The Top-level Driver replicate() The replication process starts with the following top-level driver, which calls the recursive routine replicatemotif() to create the rest of the pattern. replicate ( motif ) { for ( j = 1 to q[1] ) { qtran = edgetran[1] ; replicatemotif(motif,qtran,2,max_exp); } } qtran = addtotran ( qtran, -1 ) ; 38

39 The Recursive Routine replicatemotif() replicatemotif(motif, intran, layer, exposure) { drawmotif ( motif, intran ) ; if ( layer < maxlayers ) { pshift = pshiftarray[exposure] ; verticestodo = p - verticestoskiparray[exposure] ; for ( i = 1 to verticestodo ) { ptran = computetran(initialtran, pshift) ; first_i = ( i == 1 ) ; qtran = addtotran(ptran, qshiftarray[first_i]) ; if ( ptran.orientation > 0 ) vertex = (ptran.pposition-1) % p ; else vertex = ptran.pposition ; polygonstodo = q[vertex] - polygonstoskiparray[first_i] ; for ( j = 1 to polygonstodo ) { first_j = ( j == 1 ) ; newexpose = exposurearray[first_j] ; } } } replicatemotif(motif, qtran, layer+1, newexpose) ; qtran = addtotran ( qtran, -1 ) ; } pshift = (pshift + 1) % p ; 39

40 A Three Element Pattern with Different Numbers of Animals Meeting at their Heads 40

41 A Three Element Pattern with 3 Bats, 5 Lizards, and 4 Fish Meeting at their Heads 41

42 A Three Element Pattern with 3 Bats, 5 Lizards, and 4 Fish Meeting at their Heads 42

43 4. Future Work Fix the non-regular polygon tessellation algorithm so that it does not make duplicate copies of the motif at some locations. Allow some or all of the vertices of the fundamental polygon to lie on the bounding circle. Automatically generate patterns with color symmetry. 43

44 The End I hope not! 44

45 Escher s Euclidean Notebook Drawing 42, based on the {4, 4} tessellation. 45

46 A Hyperbolic Shell Pattern Based on {4, 5} 46