Exploring a Design Space for Patterns and Tilings Competition 2015

Aus de_evolutionary_art_org
Wechseln zu: Navigation, Suche

zurück zur Liste der Wettbewerbe zur Evolutionären Kunst


Under Construction Under Construction Under Construction Under Construction Under Construction Under Construction Under Construction

Inhaltsverzeichnis

Introduction

The goal of this periodic programming competition is to develop methods that can explore a very general but on the other hand specific design space of patterns and tilings (see DS-definition, Note to pattern), implement those methods and apply them to built alongside a repository of generation commands for interesting patterns and tilings that could be used directly in image editing by contemporary and future artists, illustrators, designers, ... under an appropriate open source license.

In image editing a mathematical compass and straight-edge construction approach is not helping. One must be able to built these structures by prototiles shaped cut-out image parts. For example: The red equilateral triangle on transparent background in the figure below is the prototile that assembles the p3m1 symmetry group image. To built a tile with it would lead to a red image (possible with some gaps) which is good for counting possible gap pixel but not so useful for image editing purposes. Therefore the red shape is used as a mask together with a parent image; with the right type of compositing function a triangle part of the parent image is cut out (p3m1_G1); again with transparent background. With such a prototile a pattern generation in image editing makes sense and could done by a sequence of image processing commands (CRMT-commands: clone the prototile, rotate it, mirror it, translate it over a pattern image to a specific position).

P3m1 Prototile.png


As a proof of concept there are reference implementations for several tiles of the euclidean symmetry groups with the CRMT-approach (see the following four images) and there is a reference implementation for an CRMT-bitmap-image-interpreter in PerlMagick; for older examples of implementations of the euclidean symmetry groups with non CRMT methods by G. Bachelier 2007 with PearlMagick see References & Links.

Pmm tile after crmt 04.jpg P4m tile after crmt 08.jpg

Tile after diagonal workaround.jpg

P6m tile after crmt 28.jpg


There are (or were) software that are using tiles in image editing like the Photoshop filter Terrazzo from Xaos Tools, the Photo Tiling Tool Pavimenta (António Salgueiro: Pavimenta: A Photo Tiling Tool. In: Bridges 2011. Pages 515–518) and the GIMP filter Texturize. The first two were not available any more and they were only using the 17 euclidean symmetry groups of the plane and none of the diversity of the other tiling methods. There is also the possibility to make tilings in vector graphic programs like Illustrator (here) and Inkscape (here), but again only the 17 symmetry groups were available.


The search for a pattern generation procedure could be thought as a 2D packing problem with overlap → min ∧ gap → min in combination with a learning/optimization procedure to generate a sequence of image processing commands that could built a pattern with given prototiles from scratch. Or it can be viewed as a puzzle solving problem were the prototiles are the puzzle elements that are moved over a plane and put together to built tilings and patterns.

An Evolutionary Algorithm environment could process this 2D packing problem like a physical puzzle (dissection puzzle, Tangram, T puzzle, tiling puzzle, eternity puzzle, geometric magick square, jigsaw puzzle). A complex example is the physical "Zellij Multipuzzle" (Jean Marc Castera: Zellij Multipuzzle. In: Bridges 2006. Pages 665–666), which implements a puzzle based on Islamic tilings and ornaments with an extreme number of 21 prototile types (see following images from Castera: Zellij Multipuzzle) and a total number of 669 prototiles (plus different boarder pieces) where one side is colored in white, the other in a different color. The task is to pack a number of prototiles together with no gap and overlap. In the case of the Zellij Multipuzzle there is a large design space of configurations with and without symmetries that satisfy this condition which means that they are all in the Pareto front of this 2-objective problem "overlap → min ∧ gap → min" and the Evolutionary Algorithm environment should be able to return all of the elements in the Pareto front.

Zellij Prototiles Physical Zellij Multipuzzle


The advantage of the command list approach is the separation of learning and application: The learning procedure can be one of the many alternatives from symbolic AI, statistical learning, Neuronal Networks to Evolutionary Computation so a huge number of researchers from diverse fields could potentially participate in this contest. Regarding to the method independent approach this type of competition is similar to the data science competitions at Kaggle. Nevertheless the focus should be on Evolutionary Computation because of the embedment in an Evolutionary Art context (also this should not be excluded for later competitions). On the other hand if a command list that generates a pattern from prototiles is available an image interpreter can use this list (and modified it) in every other programming and script language independent of the learning environment. And because the elements in the command list are logically independent from another they can be parallelized on this level which is of use especially if the image operations are also parallelized like in a programming language that can use the GPU (like OpenGL, Vulkan, OpenVG or OpenCL).

There is evidence that Shape Grammars are well suited to represent patterns and tilings (for example: Ulu & ŞENER: A SHAPE GRAMMAR MODEL TO GENERATE ISLAMIC GEOMETRIC PATTERN. In: Generative Art 2009; Cenani & Cagdas: A Shape Grammar Study: Form Generation with Geometric Islamic Patterns. In: Generative Art 2007) therefore Grammatical Genetic Programming Systems would be one obvious choice for a learning environment.

Competition terms

  • In the first competition the task is to built an learning environment (or Evolutionary Algorithms environment) that can reproduce as much as possible of the known tilings with the CMRT command list approach. The environment must be open source or at least freely available and all settings must be made public available without any restrictive licensing.
In a first step the prototile or prototiles of a known tiling/pattern were identified based on an image from the Tiling Database by Brian Wichmann. This could be done by human expertise, interactively or automatic if a good enough tile image is given. Automatic approaches must have some knowledge about euclidean geometry to correct measured angles and length which is quite a task in experimental mathematics to deduce closed forms from measures. The tiles in the Tiling Database are available as hight quality PDF (EPS) so they can be processed in an vector graphic program. This leads to the hypothesis that there are automatic methods to extract the prototiles (vector objects) that are easier and more exact than extraction from hight resolution bitmap images.
If the additional condition is given that a tile image should be reproduced exactly one can not only identify the types of prototiles but also the number of each prototile type. Even the different coloring of the prototiles in the hight quality PDFs could be used to define different protototile types. With this information an obvious stop criteria would be the use of all the members in the given prototile set.
In a second step prototile images were generated were monochrome prototiles are exactly drawn on a transparent background with no borders. The width and height measures of the prototiles must be balanced so that they fit together and could built a tile or pattern. The width and height of the prototile images define the width and height of the pattern image (see the Notes to pattern image). If a prototile is specified by one length (like the width of a equilateral triangle in the p3m1 case), the length should be specified with 1000 pixels.
If the general goal would be solely reproducing existing tilings one could use existing algorithms for example in math environments like Mathematica in combination with a general strategy to generate CRMT command lists for any geometrically constructed pattern. But because the wider goal is exploring a design space such approaches should not be accepted. On the other hand Evolutionary Algorithms are in some cases implemented in math environments like Christian Jacobs Evolvica for Mathematica so exploring the design space with Evolutionary Algorithms in such an math environment would be honored.
  • Each competitor (person or team) must verify the capability of his approach by submitting a minimum number of different tiles from different tile classes from "B. Wichmann: The world of Patterns" or the Tile Database (number of tiles and number of tile classes must be specified).
  • The winning condition is the maximal number of submitted different tiles from different tile classes.
  • For the proof of the number of submitted tiles and their verifiability each competitor (person or team) must register in a wiki design_space_for_patterns_and_tilings (to be made) and every submitted tile must be documented there with the given page template (template sketch must be further specified).
  • Every entry in the template (text, code, command lists, images, ...) is published under a creative commons license that allow the unrestricted use for all non-commercial and commercial purposes for contemporary and future artists, illustrators, designers, ... Note to CC license
  • Extended Registration of the competition can be made between 01.05.2015 and 15.12.2015. !!!
Backup-Strategy: Use a competition Web Site like Kaggle if no registrations or no serious registrations are made and extend the other dates.
  • Between 16.12.2015 and 15.01.2016 contributions can be made.
  • Announcement of the winner is 15.04.2016.

Prize money

The winner of the first competition will get a money price of minimum 500 EUR (dependent if addition sponsors are filling in).


Definition of a pattern generation task

Given:

  1. One or more prototiles (polygon shapes): $S1 ( ..., $Sn) given as png files where the shape points are touching the canvas boarders and with transparent background. The shapes are monochromatic.
  2. A pattern image $P with width $w_P and height $h_P that should be covered with the prototiles. Notes to pattern image
  3. A set of image processing commands like (clone, rotate, mirror, translate). Note to pattern image and image processing commands- Note to 6-tuple extension approach
  4. A fitness condition: overlap → min ∧ gap → min (which defines the problem as a 2-objective minimization problem). Notes to fitness condition


Wanted:

The Pareto front of solution candidates consisting of image processing command lists $comdo_list_j regarding to the 2-objective minimization problem overlap → min ∧ gap → min (graphical each solution is a point in a Cartesian coordinate system with one axis is the gap measure and the other is the overlap measure). Each command list consists of 6-tuples $6_tuple_j_k of parameters for five CRMT commands:

  1. coding of the clone command by using a prototile number that refers to a prototile in an image list $Shape_list: {0, ..., n}.
  2. coding of the rotate command: [0,360[ degrees. Note to rotation
  3. coding of a mirror command Flop: Fo.
  4. coding of a mirror command Flip: Fi.
  5. coding of a translate command with one value for the x-axis and one for the y-axis in one ($T) or two separate commands ($x, $y). Notes to translation

Example implementations show that we must use a flexible coding scheme regarding the positions of the rotate and mirror commands because there are some combinatorial cases to consider that must be distinguished because the image processing commands are in general not commutative (the sequence matters). This means that a simple coding scheme with fixed positions like ($C, $Fo, $R, $Fi, $x, $y) can not be used.

First of all one can say that the position of the clone and the compositing command is fixed: it is the first and last place in the command list. Regarding the rotate and the two mirror commands the following combinations are possible (including the first case were none of them were applied):

($C, $x, $y), ($C, $R, $x, $y), ($C, $Fo, $x, $y), ($C, $Fi, $x, $y), ($C, $Fo, $R, $x, $y), ($C, $R, $Fo, $x, $y), ($C, $Fi, $R, $x, $y), ($C, $R, $Fi, $x, $y), ($C, $Fo, $Fi, $R, $x, $y)=($C, $Fi, $Fo, $R, $x, $y), ($C, $R, $Fo, $Fi, $x, $y)=($C, $R, $Fi, $Fo, $x, $y), ($C, $Fo, $R, $Fi, $x, $y), ($C, $Fi, $R, $Fo, $x, $y)

Therefore it is necessary to also code the type of command like 'C' for clone, 'R' for rotate, 'Fo' for Flop, 'Fi' for Flip, 'x' for x-translation and 'y' for x-translation.

The next fact that must be included is the use for parameters with the C, R, x, and y command:

$C = 'C' . $prototile_nr;

$R = 'R' . $rotation_degree;

$x = 'x' . $x_value;

$y = 'y' . $y_value; (or $T = 'T' . '_' . $x_value . '_' . $y_value;)

With this components a flexible coding is possible that consider all possible positions of the commands. For example (C0, Fo, R-60, Fi, x250, y0) is coding the following processing pipeline:

  1. Clone first prototile in image list (when list numbering starts with 0)
  2. Flop
  3. rotate it -60 degree (plus additional correction of rotation offset ( Note to rotation))
  4. Flip
  5. composing_over with x-value of 250 and y-value of 0

In PearlMagick this would be implemented as (see for details the reference implementation of a p3m1-tile):

$prototile_crm = $Shape_list->[0]->Clone();
$prototile_crm = Flop();
$prototile_crm->Rotate(degrees=>'-60', color=>'transparent'); 
$prototile_crm->Trim(); 
$prototile_crm->Flip(); 
$tile->Composite(image=>$prototile_crm, compose=>'over', x=>'250', y=>'0', color=>'transparent', matte=>'true');


Required components

1) Automatic Programming environment/Evolutionary Algorithm environment that generates populations of solution candidates.

2) Image-interpreter that generates candidate images from the solution candidates by using a graphic program or library (like Image Magick or OpenGL).

3) Fitness-evaluator that is counting the gap pixels and compute the overlapping pixels of the candidate images with the help of the command list.


Procedure

The following over all pseudo code assumes that the fitness evaluation can be done after a candidate image was generated and did not need to be inside the image generation process. Because of the lack of a technical definition of an overlap measure that can be computed only with the result image and the corresponding command list it is unclear if this kind of procedure is possible.

Use the Evolutionary Algorithm-environment to generate an initial population of solution candidates: $comdo_list_t_0_j, j = 1, ..., n; 
Until ($stop_criterion == 0) {
 Use the Image-interpreter with solution candidates and given prototiles as input to generate candidate images: $image_t_j;
 Use the Fitness-evaluator to compute the fitness values $gap_j and $overlap_j for every candidate image;
 Check the stop criterion;
 if ($stop_criterion == 0) {Use the EvoAlgo environment for reproduction: apply a 2-objective method to generate a new population of solution candidates $comdo_list_t+1_j, j = 1, ..., n with the help of the fitness values} else {stop}; 
};

Definition of the Pattern Design Space

The combinational pattern design space of this idea could be written as the Cartesian product

PDS = S(poly) x S(com) x S(fit) x S($P) x S(dim) x S(geo)

with

  1. S(poly): Set of possible prototiles (if one prototile is used) or set of combinations of possible prototiles (if more than one prototile is used) Note on pattern coloring
  2. S(com): Set of possible commands (with {clone, rotate, mirror, translate} as the minimal set)
  3. S(fit): Set of possible fitness conditions
  4. S($P): Set of possible sizes of pattern image $P
  5. S(dim): Set of possible dimensions
  6. S(geo): Set of possible geometries

In the first run/runs of this programming competition the Design Space should be constrained:

  1. S(poly) = Set of prototiles that are generating a known tile or set of combinations of prototiles that are generating together a known tile.
  2. S(com) = {clone, rotate, mirror, translate}.
  3. S(fit) = {overlap → min ∧ gap → min}.
  4. S($P) = {($w_P, $h_P) = f($mult, $w_S_i, $h_S_i | i = 1, …, n)}, for example: $mult = 4, $w_P = $mult * max($w_S_i | i = 1, …, n), $h_P = $mult * max($h_S_i | i = 1, …, n).
  5. S(dim) = {2}.
  6. S(geo) = {euclidean}.


Sketch of a symbolic approach to tile generation

In the following a sketch of a tree based approach for tile generation is given for the special case that one edge of a polygon prototile is paired with one edge of an other or the same prototile type.

For example a shape S1 (a triangle with the corners C1,1 C1,2 and C1,3) and S2 (a hexagon with the corners C2,1 C2,2 ... C2,6) are given. S1 has the edges e1,1 = |C1,3 C1,1|, e1,2 = |C1,1 C1,2| and e1,3 = |C1,2 C1,3|. S2 has the edges e2,1 = |C2,6 C2,1|, ..., e2,6 = |C2,5 C2,6|.

In the first preprocessing step the binary edge pairing arrays are made. Let M1,1 be the 3x3 array where the 3 edges from S1 are paired, M1,2 the 3x6 array where the 3 edges from S1 and the 6 edges from S2 are paired and M2m2 the 6x6 array where the 6 edges from S2 are paired. A cell in an array has the value 1 if the two paired edges has the same length and 0 otherwise.

In the second preprocessing step corresponding CRMT arrays are made that will be used for the overlap tests for prototile configurations. In every cell with the value 1 a CRMT command is inserted. For exapmle the first cell in M1,2 paires e1,1 with e2,1. If the cell has a value 1 then a CRMT command is needed that "put edge e2,1 of S2 at edge e1,1 of S1". This means that a command with specific parameters is needed that cloned S2, rotate it, mirror it and translate it so that e2,1 fit to e1,1. One should be aware that there are always four possibilities to put two edges of two shapes together which are distinguished by the mirror commands: If e1,1 and e2,1 are paired this can be made by putting the corners C1,3 and C2,6 or C1,3 and C2,1 together.

The patern generation process starts with an initialisation by putting one of the prototile in the middle of the pattern image P. Then it takes all edges of the prototile and builds with a tree structure all possible pairings with all prototile types resulting in the first tree level. Depending on the kind of tree search branches are tested if the result in an overlap which cause the termination of that branche. The tests are made by actually generate a pattern with CRMT commands and monochrome (white) prototiles. A set based compositing operation can determine overlapping as the intersection of prototiles. The generation of a tree level is restricted to those edges that are in the pattern image P.

The generation process produces tree level after level around the center prototile in a concentric fashion until the stop criteria holds where all outward edges of the patten structure are outside the pattern image P.

One drawback of the procedure is that gaps within the pattern structure are not recognized. If those branches should be eliminated one has to expand the test phase to an other specific test.

Public Relation strategy for the Competition




  • Mail in mailing lists of Imape Processing
    • comp.graphics.algorithms (11.05.2015, 18.09.2015)
    • de.comp.graphik & de.comp.software.graphik (11.05.2015, 18.09.2015)
    • sci.image.processing (11.05.2015, 18.09.2015)



  • Mail in mailing lists of Mathematics (Geometry)
    • sci.math: (06.05.2015)









Future Directions

Fitness functions

Experiments with extended or other fitness conditions. It is argued that the 2-objective fitness condition is too weak and as a consequence produces too large Pereto sets. To counteract this one or more additional fitness conditions should be introduced for example that recognize symmetries. Another large field is the definition of appropriate aesthetic measures for tilings and patterns: S(fit) = {overlap → min ∧ gap → min ∧ F(aest) → max}.

Image manipulator

Extend the image interpreter to an image manipulator that manipulates the CRMT command lists and/or the associated list with prototiles/shapes. A design space of possible types of manipulations could be developed and this space could be explored with evolutionary methods, which requires again aesthetic fitness measures if such an exploration should be done automatically. This approach has connections to the tile'ish patterns below. Two use cases should be described: black and white (or gray scale) prototiles and color prototiles.

- If black and white prototiles are used it doesn't matter if large gap artifacts arises if a prototile is rotated or translated because such a black region is becoming part of the black background (if the result is written in jpg). Such black and white patterns could be used as masks for color images and the outcome of the command list manipulations are interesting mask variants with conserved or broken symmetry.

- If color prototiles are used large black region can be considered as aesthetically disruptive. In such a case a colorized background should be used perhaps the pattern that arises from the non manipulated CRMT command list, a transformed version of this, or a pattern with other color prototiles.

Example: If there is a symmetric black and white tile/pattern is used like a p3m1-tile with its top-bottom symmetry two corresponding local CRMT command lists are identified and manipulated accordingly for example by translating the top triangle more to the top and the bottom triangle more to the bottom. In this case the symmetry is preserved but in the same time the symmetry of the p3m1-tile becomes broken.

Non fitting prototiles

Experiments with prototile sets that do not fit exactly together viz tiles and pattern with known gaps (and/or overlaps) that are nevertheless interesting and aesthetic (tile'ish patterns). The fitness condition must be modified in this cases from a minimization to a sufficiency condition and possibly an appropriate aesthetic measure would be needed to explore this design subspace automatically.

Finite subdivision rules

Reverse approach by Finite subdivision rules: Given is a shape that acts like the pattern image $P with a given tiling. A subdivision rule changes that tiling by subdividing the given polygon into smaller polygons which can be continued iteratively. After a stop criteria holds the given tiling is analyzed (by hand, interactively or automatic) to identify the polygon types (prototiles) and the number of each type that built together the tile. Then a tile learning procedure (from previous iterations of the competition) generates a command list that pushes the prototiles together so that the tiling can be used for image editing purposes. The use of evolutionary computation can be twofold here: First a Genetic Programming approach can search for subdivision rules with interesting and aesthetic results and in the second step an evolutionary algorithm search for a command list that reproduces the pattern from the given prototile set.

Growing and shrinking patterns, L-systems

Is a finite set of shapes in a initial configuration given, there are ways to envolve this situation by changing the number of shapes by a growing or shrinking function (see Note on pattern). For example the work of art Evolution: Progression + Symmetry (Fibonacci) from Rune Mields could be seen as a growing function of triangles based on the Fibonacci sequence of integers. The number of triangles grow or shrink by this kind of changing pattern. The triangles can be seen as prototiles and the sequence of the patterns can be generated by CRMT command lists.

An other kind of growing and shrinking are serial images where shapes are changed which has connections to the deforming ornaments. Examples for this kind of functions can be found in the serial paintings of Attila Kovacs like the Verwandlung images (for example Verwandlung) where a shape is shrinked to a minimum and then this configuration is grown to an other shape. In contrast to a discrete changing in the example of the work from Rune Miles this could be seen as a continuous changig. The resulting shapes could be used as masks for photo pattern tools but details has to be specified like the usage of CRMT command lists.

One could think of a competition that explores a design space of growing and shrinking algorithms with genetic programming methods that evolve an initial pattern configuration to produce sequential works of art. Technically L-systems and their extentions might be used as representations that will be evolved.

Generalized Tangrams

Explore relationships to generalized tangram: Generating of prototiles by subdivision of a shape and searching for interesting/aesthetic configurations of the prototiles within a larger pattern image (no gap → min condition).

Vector graphics

Experiments with vector graphics: There are possibilities to script vector objects in Inkscape: Four ways to generate or process Inkscape vector graphics automatically. With --verb on the command line Inkscape can process basic geometric commands like --verb ObjectFlipVertically, but because the verb-approach can not process parameters it is not yet clear if this approach is directly powerful enough to interpret the CRMT-lists. But SVG images are defined in XML files therefore components of vector objects and their behavior can be edited with text editors so methods and parameters could be specified on this way. In conclusion it seems plausible that a CRMT-vector-image-interpreter could be made, that takes a vector object in the shape of a prototile and a CRMT-command list and generates a tile or pattern.

Inkscape has the ability to generate tiles but again restricted to to plane groups. With the use of CRMT-lists the large design space of tilings and pattern could be used in vector graphic formats.

Inkscape is able to cut out vector image parts with the Clipping and Masking methods. If a clipping path is shaped like a polygon it can be used to generate a color prototile that a CRMT-command list transforms to a tile or pattern.

Additional processing commands

Experiments with additional image processing commands: scale; affine matrix transformation or more general the distortion transformations in ImageMagick with affine and lots of other parameters (http://www.imagemagick.org/Usage/distorts/): Affine, AffineProjection, ScaleRotateTranslate SRT, Perspective, PerspectiveProjection, BilinearForward, BilinearReverse, Polynomial, Arc, Polar, DePolar, Barrel, BarrelInverse, Shepards, Resize. Even with an added scaling command there are iterative function systems IFS possible with the opportunity to explore the aesthetics of self similarity within the general design space approach.

Ornament deformations

Parquet/ornament deformations (see Craig S. Kaplan: Computer Graphics and Geometric Ornamental Design, pp. 57): Searching for interesting/aesthetic mathematical deformation functions, analyzing the deformed ornaments to identify the polygon types (prototiles) and the number of each type that built together the ornament just like in the case of the Finite subdivision rules. Then using a pattern learning procedure that can reproduce the deformed ornament with CRMT-command lists. Again evolutionary computation can be used for searching deformation functions and for the learning process whereat the number of prototile types could become very large because every layer of the parquet has slightly different types and therefore the number is also dependent of the range of the parquet.

Autonomous, selforganized, distributed and fast exploration

Looking for strategies to autonomously explore such kind of design spaces. Because of the large range of such spaces fast strategies are necessary like the use of GPUs for testing candidate images and aesthetic fitness evaluation with machine learning models (like deep learning). Distributed processing offers the possibility to explore many points of a design space region in parallel which is conceptually adequate for Evolutionary Computation and Art and should be realized by quasi-standard BOINC-implementations.

Comments and Suggestions

Comments and suggestions to all aspects of the competition project are appreciated and should be addressed to Dr. Günter Bachelier (guba at evo-art.org).


Notes

Note to pattern

As a wide ranging working definition of (static) pattern a composition of shapes (or prototiles) is used here. With the attributes gap and overlap there is a classification with four possible types of static patterns:

  1. gap ∧ overlap
  2. ¬gap ∧ overlap
  3. gap ∧ ¬overlap => (generalized) tangram
  4. ¬gap ∧ ¬overlap => tiles

Considering a dynamic of patterns the attributes number and form of shapes lead to an additional classification. Let n be the assertion "number of shapes is constant" and f be the assertion "form of shapes is constant" there is a classification with four possible types of dynamic patterns; see Future Directions:

  1. n ∧ f => different configurations of the same shapes
  2. ¬n ∧ f => growing (and/or shrinking) patterns (see for example: Rune Mields: Evolution: Progression + Symmetry (Fibonacci))
  3. n ∧ ¬f => deforming patterns
  4. ¬n ∧ ¬f => subdivision patterns

One can combine every of the four dynamic pattern types with each of the four static pattern types, for example:

  1. (n ∧ f) ∧ (gap ∧ ¬overlap) as a generalized tangram that changes it configuration at every time step where the number and the form of the shapes remain constant
  2. (n ∧ ¬f) ∧ (gap ∧ ¬overlap) as a generalized tangram that changes it configuration at every time step where the number of the shapes remain constant but at least one shape alter its form from one time step to the next


It is also possible to define different design spaces of hyderdynamic patterns where every point at such a desin space is a sequence of pattern types. For example if one selects at every time step one of the four dynamic pattern types one gets a nf-Sequence:

nf-Sequence = (nf(t), t = 1, ... | nf(t) ∈ {n ∧ f, ¬n ∧ f, n ∧ ¬f, ¬n ∧ ¬f}).

Note to CC license

Notes to pattern image

  • Mathematical tile generation algorithms are in principle able to generate a pattern with any width x hight. The search for a program (with a Genetic Programming environment) that is able to generate an image command list for pattern generation for an arbitrary pattern size is more complex than the search for a program that generates a command list for only one specific image size. Therefore one should restrict the underlaying problem to the later case.
  • A predefined pattern image $P has the disadvantage that it does not reflect the size of the prototile/s. A pattern should be large enough that one can see the regularities but it should be restricted because the cost of generating is growing fast with the size of the pattern. Therefore the width and hight of the pattern image should be a function of the width and height of the prototile/s and a multiplier $mult: ($w_P, $h_P) = f($mult, $w_S, $h_S) or ($w_P, $h_P) = f($mult, $w_S_i, $h_S_i | i = 1, …, n). A 3x3- or 4x4-pattern (for periodical tilings) should be sufficient and for the function with prototiles one could for example determine the prototile with the largest number of pixels and use its width and hight.

Note to pattern image and image processing commands

In the work about the euclidean symmetry groups G. Bachelier used a slightly different approach for the pattern image and the processing commands ( References & Links). The generation process of a tile begins with one shape (equals the pattern image) and this image is successively extended at one of its four edges and then a shape of the same type is rotated, mirrored and translated in one of the edges of the extended image. This means that the tile is growing until it has reached its full size so the command list used in this variant would be (clone, rotate, mirror, extent, translate) (see: http://www.imagemagick.org/Usage/crop/#extent or "Extent" method in http://www.imagemagick.org/script/perl-magick.php). With the parameters width=>integer and height=>integer the new size of the tile part is defined and with gravity=>{NorthWest, North, NorthEast, West, Center, East, SouthWest, South, SouthEast} it is defined where to insert an image part with background=>'transparent'. The advantage of this approach is that one needs only the gravity-parameter with its 8 possible values for the translation instead of the x and y values. Possibly such an extend-approach would be more efficient because it reduces the search space of the optimization problem but on the other hand this has the risk of becoming trapped in a local sub-minimum.

Notes to fitness condition

  • This 2-objective minimization is independent of any kind of aesthetic measure. The definition of an appropriate measure for tilings/patterns built with monochrome shapes should be part of one following competition.
  • The definition of gap is obvious as the number of transparent pixel in a candidate image and can be determined with the result image without the knowledge of the generation process viz the command lists. The definition of overlap is more complex and it must quantify the number of pixels of the pattern image that are covered more than one time during the generation process. The question is if such a measure can be computed with the result image and the command list or must it be computed during the generation process. The later requires the integration of the Fitness-evaluator in the Image-interpreter.
The overlap of two shapes can be thought as the intersection of two point sets which is in ImageMagick implemented by the set theoretic compositing method "Darken" (http://www.imagemagick.org/Usage/compose/#set_theory). The computing of the overlap in this case would require a second parallel generation process with compose_darken besides the generation process with compose_over. Every compose operation is made with compose_over for the generation of the result image and with compose_darken for the computing of the overlap measure. The measure would be the sum of the pixels of each intersection during the processing of the command list.
Given is a pattern image $P with width $w_P and height $h_P. In the beginning (t=0) $P is empty i.e. all pixel are transparent resulting in the notation $P_0. Given is also a command list with m 5-tuples ($S, $r, $m, $x, $y). From the command list the sequence @C_S = ($S | j = 1, …, m) of prototiles is extracted as the list of shapes that will be step by step composed independent if there is only one or more prototile types given.
In step t=1 the fist element from @C_S undergo a rotate and mirror transformation with the corresponding parameters $r_1 and $m_1 resulting in $S_1. $S_1 is then composed_over $P_0 with the transition parameters $x_1 and $y_1 resulting in $P_1. Because $P_0 was empty the overlap measure $overlap_1 in step 1 is always zero and the gap measure $gap_1 is computed as the number of non transparent pixels in $P_1 (if this is necessary). In step t=2 the second element from @C_S is transformed with $r_2 and $m_2 resulting in $S_2 and composed_over $P_1 with $x_2 and $y_2 resulting in $P_2 which could lead to an overlap. To compute $overlap_2 $P_1 is cloned and denoted as $P_1_d and $S_2 is composed_darken over $P_1_d with $x_2 and $y_2 resulting in $P_2_d. The overlap $overlap_2 is the number of non transparent pixel in $P_2_d equal to the number of non transparent pixels in the intersection of $P_1_d and $S_2. The overlap values could be pushed in a list @overlap_list which has after processing the whole command list m elements. The overlap measure of the whole generation process of the result image $P_m would be the sum of all m overlap values in @overlap_list.
Is it possible to make an overlap measure that can be computed given the result pattern image and the command list without the m intermediate steps? => Overlap Measure
Perhaps it is even not necessary to have such an absolute overlap measure that counts the actual pixels that are covered more than one time in the generating process of a pattern/tiling if such a measure is used in a fitness evaluation context. Possibly some kind of relative fitness value would be enough to make a fitness ranking of candidates to implement a selection strategy for reproduction.
  • Weakness of fitness condition: For the general exploration of the design space (not the reproduction of known tiles or tile images) the fitness condition might be too weak resulting in a too large Pareto front. Considering pmm with a square prototile there are 4 possible 90° rotated variants of the prototile for every 4 positions in the tile. The Pareto set has 16 elements if only rotation is taken into account where only one is the symmetry group pmm that con not distinguished from the other elements without an additional fitness condition. And if translation is considered besides rotation the Pareto set is not manageable because it is larger than the number of pixels in the pattern image.

Note to rotation

If a shape is rotated the ratio of the image can increase and the shape is not any more touching the image borders. This has consequences for the following translation because the translation in ImageMagick uses the left upper point as reference for the x- and y-value and uncorrected this would lead to gaps and/or overlaps. To correct this the parameterless IM-method Trim() can be used directly after rotation ($image=>Trim();)

Notes to translation

  • If one uses an interpreter that can not use sub-pixel precision a naive range would be: x: [0, ..., $w_P - 1] and y: [0, ..., $h_P - 1]. But one must allow negative values to compose shapes in a way that the boarder regions of the pattern canvas are covered. Be w_shape_before_translate the width and h_shape_before_translate the height of the shape canvas before the translation the ranges are expanded to x: [-w_shape_before_translate + 1, ..., $w_P - 1], y: [-h_shape_before_translate + 1, ..., $h_P - 1]. (In PerlMagick the translate command would be integrated in a compose_over-command with absolute x and y coordinates.)
  • A decision must be made if absolute pixel positions in an pattern image should be used like in the CRMT-tuples or relative values regarding to the width and height of the prototile if only one prototile is used or the width and height of tile/pattern image.
  • If an image-interpreter is used which relies on a graphic program or library that can not use subpixel accuracy it is shown (in PerlMagick implementations of the euclidean symmetry groups) that gap artifacts could be generated at edges where the prototile polygons fit together. This is often the case if the polygons have other angles than {90, 45}°. If such tiles or patterns are saved in file formats that did not support transparency like jpg the gap pixel are set to black which result in viewable artifacts. A simple image editing heuristic was developed to fill all the gap pixel with local content by compose=>'over' the pattern over a slightly enlarged version of itself. In the case of the fitness evaluation it might be reasonable to distinguish between such gap pixel lines that can be corrected in image editing contexts and two-dimensional gap defects that can not locally corrected.

Note to 6-tuple extension approach

Alternatively an approach could be used that begins with one prototile (with transparent background) and iteratively extend the image until the given width and hight of the pattern is reached. This requires and additional image processing command (Extent()) and results in a 6-tuple:

  1. coding of the clone command by using a prototile number that refers to a prototile in an image list $Shape_list: $C = 'C' . $prototile_nr; $prototile_nr from {0, ..., n}.
  2. coding of the rotate command: $R = 'R' . $rotation_degree; $rotation_degree from [0,360[.
  3. coding of a mirror command Flop: $Fo.
  4. coding of a mirror command Flip: $Fi.
  5. coding of an extent command with two parameters: $E = 'E' . $gravity . '_' . $extention_value.
    1. gravity=>{North, West, East, South}. (simplified list of gravity options)
    2. delta-extension in pixel.
  6. coding of a translate command for the composite command : $T = 'T' . '_' . $gravity (or $xy = 'xy'. . $gravity).
    1. gravity=>{NorthWest, North, NorthEast, West, Center, East, SouthWest, South, SouthEast}. (full list of gravity options)

For example a 6-tuple (C0, Fo, R-60, Fi, E_West_250, T_West) would be interpreted as:

  1. Clone first prototile in image list (when list numbering starts with 0).
  2. Flop.
  3. rotate it -60 degree (plus additional correction of rotation offset).
  4. Flip.
  5. extent the tile on the left side (= west) of 250 pixels.
  6. composing the prototile over the tile and set the prototile at the left boarder of the tile (= geometry: West).

In PearlMagick this would be implemented as:

$prototile_crm = $Shape_list->[0]->Clone();
$prototile_crm = Flop();
$prototile_crm->Rotate(degrees=>'-60', color=>'transparent'); 
$prototile_crm->Trim(); 
$prototile_crm->Flip(); 
($w, $h) = $tile->Get('columns', 'rows');
$w_new = $w + 250; 
$tile->Extent(gravity=>'West', width=>$w_new, height=>$h, background=>'transparent'); 
$tile->Composite(image=>$prototile_crm, compose=>'over', gravity=>'West', color=>'transparent', matte=>'true');

Note on pattern coloring

The prototiles in mathematical constructions of tiles are first of all monochrome with one color independent if one or more prototile types are used. There are many ways to color a pattern by assigning different colors to a prototile at different positions of the pattern or different colors to different types of prototiles. The set of possible coloring algorithms could be an additional dimension of the design space but for to underlying goal of using patterns for image editing this is not necessary. One can substitute a coloring rule system by enlarging the set of prototiles so that every color correspond to new added prototile type. If for example a tiling is used with one prototile and a coloring rule system with three colors one could enlarge the set of prototiles to three.

References & Links

  • Descriptions of some euclidean symmetry groups with a modified clone-rotate-mirror-translate-approach (G. Bachelier 2007): (note: web links in the pdf's are not valid any more)
  1. http://www.vi-anec.de/Trance-Art/IM-examples/IM-plane_group_pmm/pmm_e.pdf
  2. http://www.vi-anec.de/Trance-Art/IM-examples/IM-plane_group_p4m/p4m_e.pdf
  3. http://www.vi-anec.de/Trance-Art/IM-examples/IM-plane_group_p3m1/p3m1_ges_e.pdf, internal link
  4. http://www.vi-anec.de/Trance-Art/IM-examples/IM-plane_group_p6m/p6m_e.pdf
  5. http://www.vi-anec.de/Trance-Art/IM-examples/IM-plane_group_p3/p3_e.pdf
  6. http://www.vi-anec.de/Trance-Art/IM-examples/IM-plane_group_p31m/p31m_e.pdf


Tiling Classification in "B. Wichmann: The world of Patterns"

Mathematical

Regular polygons all having the same edge length (254 Tiles)

1.1.1) The simplest form of tiling pattern with only regular polygons are those known to the Greeks (these have only one type of vertex): Archimedean tilings

  • World_of_Patterns/maths/Regular/OneUni/ (html/F33.htm, tgif/F33.gif, ...) (12): F33, F36A, F36B, F34A, F3434, F3464, F3636, F312, F4, F4612, F48, F666


1.1.2) The next simplest category of tilings with regular polygons are those with two different types of vertices

  • World_of_Patterns/maths/Regular/TwoUni/ (20): F3412, F3462A, F3462B, F346A, F346B, F346C, F346D, F346E, F346F, F346G, F34A, F34B, F34C, F34D, F34E, F34F, F36A, F36B, F36C, F36D


1.1.3) The obvious generalization of the above are those tilings with three different types of vertices

  • World_of_Patterns/maths/Regular/ThreeU/part1/ (42): F33B, F49A, F49B, F51C1, F51C10, F51C11, F51C12, F51C13, F51C14, F51C15, F51C16, F51C17, F51C18, F51C19, F51C2, F51C20, F51C21, F51C22, F51C23, F51C24, F51C25, F51C26, F51C27, F51C28, F51C29, F51C3, F51C30, F51C31, F51C32, F51C33, F51C34, F51C35, F51C36, F51C37, F51C38, F51C39, F51C4, F51C5, F51C6, F51C7, F51C8, F51C9
  • World_of_Patterns/maths/Regular/ThreeU/part2/ (48): F52C01, F52C02, F52C03, F52C04, F52C05, F52C06, F52C07, F52C08, F52C09, F52C10, F52C11, F52C12, F52C13, F52C14, F52C15, F52C16, F52C17, F52C18, F52C19, F52C20, F52C21, F52C22, F52C23, F52C24, F52C25, F52C26, F52C27, F52C28, F52C29, F52C30, F52C31, F52C32, F52C33, F53C01, F53C02, F53C03, F53C04, F53C05, F53C06, F53C07, F53C08, F53C09, F53C10, F53C11, F53C12, F53C13, F53C14, F53C15
  • World_of_Patterns/maths/Regular/ThreeU/part3/ (39): F54C01, F54C02, F54C03, F54C04, F54C05, F54C06, F54C07, F54C08, F54C09, F54C10, F55C1, F55C2, F55C3, F55C4, F55C5, F55C6, F55C7, F56C01, F56C02, F56C03, F56C04, F56C05, F56C06, F56C07, F56C08, F56C09, F56C10, F56C11, F56C12, F56C13, F56C14, F56C15, F56C16, F56C17, F56C18, F56C19, F56C20, F56C21, F56C22


1.1.4) Tilings formed from tiles which dissect a regular polygon

  • World_of_Patterns/maths/Regular/Splits/ (28): P10A, P10AT, P10B, P10BT, P12, P12T, P5, P5T, P7, P7T, P8, P8T, P9, P9T, S122, S122T, S125, S125T, S52, S52T, S63, S63T, S83A, S83AT, S83B, S83BT, S93, S93T


1.1.5) Tilings produced just with squares, but having different edge lengths

  • World_of_Patterns/maths/Regular/Square/ (15): F242G1, F242G2, F245A, F245B, F245C, F245D, F245E, F246A, F246B, F246C, F246D, F246E, F247A, F247B, F247C


1.1.6) Tilings produced just with equilateral triangles, but having different edge lengths

  • World_of_Patterns/maths/Regular/Triang/ (6): C15B, F242H, F244A, F244B, F244C, SCA


1.1.7) Tilings produced with a mixture of regular polygons, but having different edge lengths

  • World_of_Patterns/maths/Regular/nEtE/ (19): F242EF, F242F, F243A, F243B, F243C, F243D, F312, F3434A, F3434B, F3464A, F3464B, F346A, F346B, F34A, F34B, F3636, F4612A, F4612B, F48


1.1.8) Tilings produced with a regular polygon and another polygon having maximal symmetry

  • World_of_Patterns/maths/Regular/TwoPoly/ (25): B01, B02, B03, B04, B05, B06, B07, B08, B09, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19, B20, G7, G8, RS1, VA1, W39


1.1.9) Lastly, other shapes of mathematical interest are collected here

  • World_of_Patterns/maths/Regular/Other/ (40): F223A, F223B, F231A, F231B, F231C, F248A, F248B, F248C, F263A, F263B, F264, F755A, F755B, J2, J3, J4, J5, J6, J7, J8, J9, L102, L215, L216, L217, L2310, L2311, L255, L275, L3010, L307, L308, L3311, L338, L379, L4212, L4213, L4215, L4216, L4613


Containing mainly regular star polygons all having the same edge length (98 Tiles)

1.2.1) This part contains regular patterns with star polygons

  • World_of_Patterns/maths/Stars/Uni/ (35): B12, F215, F253A1, F253A2, F253B1, F253B2, F253C, F253D, F254A, F254B, F254C, F254D, F254E, F254F, F254G, F254H1, F254H2, F254H3, F254I, F254J, F254K, F254L, F254N1, F254N2, F254O, F254P, F254Q, F255A, F255B, F255C, F255D, F255E, F96, RM1, W49


1.2.2) This part contains regular tilings with degenerate star polygons with just four sides, ie diamonds

  • World_of_Patterns/maths/Stars/Digons/ (44): A1, D257B, D312, D3434A, D3434B, D3434C, D3434D, D346A, D346B, D346C, D346D, D346E, D346F, D346F2, D346FR, D34A, D34B, D34C, D34D, D36A, D44, D44A, D44B, D4612A, D4612B, D4612C, D4612D, D4612E, D4612F, D48A, D48B, D48C, D666, D6A, D6B, D6C, F1511A, F254I, J30, J30R, RM1, RM2, SD1, SD2


1.2.3) Other patterns with star polygons

  • World_of_Patterns/maths/Stars/Other/ (19): A329, E253, F201, F2511, F256A, F256B, F256C, F257A, F257B, F257D, F415D, F416D, F417D, F420D, F421D, F424D, KEEHH, KX, KY


Tiling patterns made entirely from one shape: Monohedral Patterns

1.3.1) Tilings in which the single shape is a triangle

  • World_of_Patterns/maths/Monoh/p3/ (14): P301, P302, P303, P304, P305, P306, P307, P308, P309, P310, P311, P312, P313, P314


1.3.2) Tilings in which the single shape is a quadrilateral

  • World_of_Patterns/maths/Monoh/p4/part1 (56): P401, P402, P403, P404, P405, P406, P407, P408, P409, P410, P411, P412, P413, P414, P415, P416, P417, P418, P419, P420, P421, P422, P423, P424, P425, P426, P427, P428, P429, P430, P431, P432, P433, P434, P435, P436, P437, P438, P439, P440
  • World_of_Patterns/maths/Monoh/p4/part2 (16): P441, P442, P443, P444, P445, P446, P447, P448, P449, P450, P451, P452, P453, P454, P455, P456


1.3.3) Tilings in which the single shape is pentagonal

  • World_of_Patterns/maths/Monoh/p5/ (24): P501, P502, P503, P504, P505, P506, P507, P508, P509, P510, P511, P512, P513, P514, P515, P516, P517, P518, P519, P520, P521, P522, P523, P524


1.3.4) Tilings in which the single shape is hexagonal

  • World_of_Patterns/maths/Monoh/p6/ (13): P601, P602, P603, P604, P605, P606, P607, P608, P609, P610, P611, P612, P613


1.3.5) Tilings formed by joining equilateral triangles together

  • World_of_Patterns/maths/Monoh/Poly3/ (706)
Polyiamonds - one to six triangles: World_of_Patterns/maths/Monoh/Poly3/d1t6/ (23): T1C1, T2C1, T3C1, T4C1, T4C2, T4C3, T5C1, T5C2, T5C3, T5C4, T6C01, T6C02, T6C03, T6C04, T6C05, T6C06, T6C07, T6C08, T6C09, T6C10, T6C11, T6C12, T6C8A
Heptiamonds: World_of_Patterns/maths/Monoh/Poly3/d7/ (24): C01, C02, C03, C04, C05, C06, C07, C08, C09, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24
Octiamonds: World_of_Patterns/maths/Monoh/Poly3/d8/ (66):
Octiamonds: World_of_Patterns/maths/Monoh/Poly3/d8/part1 (33): C01, C02, C03, C04, C05, C06, C07, C08, C09, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33
Octiamonds: World_of_Patterns/maths/Monoh/Poly3/d8/part2 (33): C34, C35, C36, C37, C38, C39, C40, C41, C42, C43, C44, C45, C46, C47, C48, C49, C50, C51, C52, C53, C54, C55, C56, C57, C58, C59, C60, C61, C62, C63, C64, C65, C66
Noniamonds: World_of_Patterns/maths/Monoh/Poly3/d9/ (159)
Noniamonds: World_of_Patterns/maths/Monoh/Poly3/d9/part1 (40): C001, C002, C003, C004, C005, C006, C007, C008, C009, C010, C011, C012, C013, C014, C015, C016, C017, C018, C019, C020, C021, C022, C023, C024, C025, C026, C027, C028, C029, C030, C031, C032, C033, C034, C035, C036, C037, C038, C039, C040
Noniamonds: World_of_Patterns/maths/Monoh/Poly3/d9/part2 (40): C041, C042, C043, C044, C045, C046, C047, C048, C049, C050, C051, C052, C053, C054, C055, C056, C057, C058, C059, C060, C061, C062, C063, C064, C065, C066, C067, C068, C069, C070, C071, C072, C073, C074, C075, C076, C077, C078, C079, C080
Noniamonds: World_of_Patterns/maths/Monoh/Poly3/d9/part3 (40): C081, C082, C083, C084, C085, C086, C087, C088, C089, C090, C091, C092, C093, C094, C095, C096, C097, C098, C099, C100, C101, C102, C103, C104, C105, C106, C107, C108, C109, C110, C111, C112, C113, C114, C115, C116, C117, C118, C119, C120
Noniamonds: World_of_Patterns/maths/Monoh/Poly3/d9/part4 (39): C121, C122, C123, C124, C125, C126, C127, C128, C129, C130, C131, C132, C133, C134, C135, C136, C137, C138, C139, C140, C141, C142, C143, C144, C145, C146, C147, C148, C149, C150, C151, C152, C153, C154, C155, C156, C157, C158, C159
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/ (444)
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/part1 (40): C001, C002, C003, C004, C005, C006, C007, C008, C009, C010, C011, C012, C013, C014, C015, C016, C017, C018, C019, C020, C021, C022, C023, C024, C025, C026, C027, C028, C029, C030, C031, C032, C033, C034, C035, C036, C037, C038, C039, C040
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/part2 (40): C041, C042, C043, C044, C045, C046, C047, C048, C049, C050, C051, C052, C053, C054, C055, C056, C057, C058, C059, C060, C061, C062, C063, C064, C065, C066, C067, C068, C069, C070, C071, C072, C073, C074, C075, C076, C077, C078, C079, C080
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/part3 (40): C081, C082, C083, C084, C085, C086, C087, C088, C089, C090, C091, C092, C093, C094, C095, C096, C097, C098, C099, C100, C101, C102, C103, C104, C105, C106, C107, C108, C109, C110, C111, C112, C113, C114, C115, C116, C117, C118, C119, C120
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/part4 (40): C121, C122, C123, C124, C125, C126, C127, C128, C129, C130, C131, C132, C133, C134, C135, C136, C137, C138, C139, C140, C141, C142, C143, C144, C145, C146, C147, C148, C149, C150, C151, C152, C153, C154, C155, C156, C157, C158, C159, C160
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/part5 (40): C161, C162, C163, C164, C165, C166, C167, C168, C169, C170, C171, C172, C173, C174, C175, C176, C177, C178, C179, C180, C181, C182, C183, C184, C185, C186, C187, C188, C189, C190, C191, C192, C193, C194, C195, C196, C197, C198, C199, C200
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/part6 (40): C201, C202, C203, C204, C205, C206, C207, C208, C209, C210, C211, C212, C213, C214, C215, C216, C217, C218, C219, C220, C221, C222, C223, C224, C225, C226, C227, C228, C229, C230, C231, C232, C233, C234, C235, C236, C237, C238, C239, C240
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/part7 (40): C241, C242, C243, C244, C245, C246, C247, C248, C249, C250, C251, C252, C253, C254, C255, C256, C257, C258, C259, C260, C261, C262, C263, C264, C265, C266, C267, C268, C269, C270, C271, C272, C273, C274, C275, C276, C277, C278, C279, C280
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/part8 (40): C281, C282, C283, C284, C285, C286, C287, C288, C289, C290, C291, C292, C293, C2094, C295, C296, C297, C298, C299, C300, C301, C302, C303, C304, C305, C306, C307, C308, C309, C310, C311, C312, C313, C314, C315, C316, C317, C318, C319, C320
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/part9 (40): C321, C322, C323, C324, C325, C326, C327, C328, C329, C330, C331, C332, C333, C334, C335, C336, C337, C338, C339, C340, C341, C342, C343, C344, C345, C346, C347, C348, C349, C350, C351, C352, C353, C354, C355, C356, C357, C358, C359, C360
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/part10 (40): C361, C362, C363, C364, C365, C366, C367, C368, C369, C370, C371, C372, C373, C374, C375, C376, C377, C378, C379, C380, C381, C382, C383, C384, C385, C386, C387, C388, C389, C390, C391, C392, C393, C394, C395, C396, C397, C398, C399, C400
Deciamonds: World_of_Patterns/maths/Monoh/Poly3/d10/part11 (44): C401, C402, C403, C404, C405, C406, C407, C408, C409, C410, C411, C412, C413, C414, C415, C416, C417, C418, C419, C420, C421, C422, C423, C424, C425, C426, C427, C428, C429, C430, C431, C432, C433, C434, C435, C436, C437, C438, C439, C440, C441, C442, C443, C444
World_of_Patterns/maths/Monoh/Poly3/Other/ (13): A349, E1, F942A, F942B, F942C, F946, S21B, S21T, S22B, S22T, S23B, S23T, W38


1.3.6) Tilings formed by joining squares together

For one to five squares: The Smaller Polyominoes: World_of_Patterns/maths/Monoh/Poly4/d1t5/ (33): C5F, C5I, C5L, C5N, C5P, C5T, C5U, C5V, C5W, C5X, C5Y, C5Z, S1C1, S2C1, S3C1, S3C2, S4C1, S4C2, S4C3, S4C4, S4C5, S5C01, S5C02, S5C03, S5C04, S5C05, S5C06, S5C07, S5C08, S5C09, S5C10, S5C11, S5C12
For six squares: Hexominoes: World_of_Patterns/maths/Monoh/Poly4/d6/ (35): C01, C02, C03, C04, C05, C06, C07, C08, C09, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22, C23, C24, C25, C26, C27, C28, C29, C30, C31, C32, C33, C34, C35
For seven squares (107):
Heptominoes: World_of_Patterns/maths/Monoh/Poly4/d7/Part1 (40): C001, C002, C003, C004, C005, C006, C007, C008, C009, C010, C011, C012, C013, C014, C015, C016, C017, C018, C019, C020, C021, C022, C023, C024, C025, C026, C027, C028, C029, C030, C031, C032, C033, C034, C035, C036, C037, C038, C039, C040
Heptominoes: World_of_Patterns/maths/Monoh/Poly4/d7/Part2 (40): C041, C042, C043, C044, C045, C046, C047, C048, C049, C050, C051, C052, C053, C054, C055, C056, C057, C058, C059, C060, C061, C062, C063, C064, C065, C066, C067, C068, C069, C070, C071, C072, C073, C074, C075, C076, C077, C078, C079, C080
Heptominoes: World_of_Patterns/maths/Monoh/Poly4/d7/Part3 (27): C081, C082, C083, C084, C085, C086, C087, C088, C089, C090, C091, C092, C093, C094, C095, C096, C097, C098, C099, C100, C101, C102, C103, C104, C105, C106, C107
For eight squares (363):
Octominoes: World_of_Patterns/maths/Monoh/Poly4/d8/Part1 (40): C001, C002, C003, C004, C005, C006, C007, C008, C009, C010, C011, C012, C013, C014, C015, C016, C017, C018, C019, C020, C021, C022, C023, C024, C025, C026, C027, C028, C029, C030, C031, C032, C033, C034, C035, C036, C037, C038, C039, C040
Octominoes: World_of_Patterns/maths/Monoh/Poly4/d8/Part2 (40): C041, C042, C043, C044, C045, C046, C047, C048, C049, C050, C051, C052, C053, C054, C055, C056, C057, C058, C059, C060, C061, C062, C063, C064, C065, C066, C067, C068, C069, C070, C071, C072, C073, C074, C075, C076, C077, C078, C079, C080
Octominoes: World_of_Patterns/maths/Monoh/Poly4/d8/Part3 (40): C081, C082, C083, C084, C085, C086, C087, C088, C089, C090, C091, C092, C093, C094, C095, C096, C097, C098, C099, C100, C101, C102, C103, C104, C105, C106, C107, C108, C109, C110, C111, C112, C113, C114, C115, C116, C117, C118, C119, C120
Octominoes: World_of_Patterns/maths/Monoh/Poly4/d8/Part4 (40): C121, C122, C123, C124, C125, C126, C127, C128, C129, C130, C131, C132, C133, C134, C135, C136, C137, C138, C139, C140, C141, C142, C143, C144, C145, C146, C147, C148, C149, C150, C151, C152, C153, C154, C155, C156, C157, C158, C159, C160
Octominoes: World_of_Patterns/maths/Monoh/Poly4/d8/Part5 (40): C161, C162, C163, C164, C165, C166, C167, C168, C169, C170, C171, C172, C173, C174, C175, C176, C177, C178, C179, C180, C181, C182, C183, C184, C185, C186, C187, C188, C189, C190, C191, C192, C193, C194, C195, C196, C197, C198, C199, C200
Octominoes: World_of_Patterns/maths/Monoh/Poly4/d8/Part6 (40): C201, C202, C203, C204, C205, C206, C207, C208, C209, C210, C211, C212, C213, C214, C215, C216, C217, C218, C219, C220, C221, C222, C223, C224, C225, C226, C227, C228, C229, C230, C231, C232, C233, C234, C235, C236, C237, C238, C239, C240
Octominoes: World_of_Patterns/maths/Monoh/Poly4/d8/Part7 (40): C241, C242, C243, C244, C245, C246, C247, C248, C249, C250, C251, C252, C253, C254, C255, C256, C257, C258, C259, C260, C261, C262, C263, C264, C265, C266, C267, C268, C269, C270, C271, C272, C273, C274, C275, C276, C277, C278, C279, C280
Octominoes: World_of_Patterns/maths/Monoh/Poly4/d8/Part8 (40): C281, C282, C283, C284, C285, C286, C287, C288, C289, C290, C291, C292, C293, C2094, C295, C296, C297, C298, C299, C300, C301, C302, C303, C304, C305, C306, C307, C308, C309, C310, C311, C312, C313, C314, C315, C316, C317, C318, C319, C320
Octominoes: World_of_Patterns/maths/Monoh/Poly4/d8/Part9 (43): C321, C322, C323, C324, C325, C326, C327, C328, C329, C330, C331, C332, C333, C334, C335, C336, C337, C338, C339, C340, C341, C342, C343, C344, C345, C346, C347, C348, C349, C350, C351, C352, C353, C354, C355, C356, C357, C358, C359, C360, C361, C362, C363
For nine squares (1248)
World_of_Patterns/maths/Monoh/Poly4/d9/Part01 (40): C0001, C0002, C0003, C0004, C0005, C0006, C0007, C0008, C0009, C0010, C0011, C0012, C0013, C0014, C0015, C0016, C0017, C0018, C0019, C0020, C0021, C0022, C0023, C0024, C0025, C0026, C0027, C0028, C0029, C0030, C0031, C0032, C0033, C0034, C0035, C0036, C0037, C0038, C0039, C0040
World_of_Patterns/maths/Monoh/Poly4/d9/Part02 (40): C0041, C0042, C0043, C0044, C0045, C0046, C0047, C0048, C0049, C0050, C0051, C0052, C0053, C0054, C0055, C0056, C0057, C0058, C0059, C0060, C0061, C0062, C0063, C0064, C0065, C0066, C0067, C0068, C0069, C0070, C0071, C0072, C0073, C0074, C0075, C0076, C0077, C0078, C0079, C0080
World_of_Patterns/maths/Monoh/Poly4/d9/Part03 (40): C0081, C0082, C0083, C0084, C0085, C0086, C0087, C0088, C0089, C0090, C0091, C0092, C0093, C0094, C0095, C0096, C0097, C0098, C0099, C0100, C0101, C0102, C0103, C0104, C0105, C0106, C0107, C0108, C0109, C0110, C0111, C0112, C0113, C0114, C0115, C0116, C0117, C0118, C0119, C0120
World_of_Patterns/maths/Monoh/Poly4/d9/Part04 (40): C0121, C0122, C0123, C0124, C0125, C0126, C0127, C0128, C0129, C0130, C0131, C0132, C0133, C0134, C0135, C0136, C0137, C0138, C0139, C0140, C0141, C0142, C0143, C0144, C0145, C0146, C0147, C0148, C0149, C0150, C0151, C0152, C0153, C0154, C0155, C0156, C0157, C0158, C0159, C0160
World_of_Patterns/maths/Monoh/Poly4/d9/Part05 (40): C0161, C0162, C0163, C0164, C0165, C0166, C0167, C0168, C0169, C0170, C0171, C0172, C0173, C0174, C0175, C0176, C0177, C0178, C0179, C0180, C0181, C0182, C0183, C0184, C0185, C0186, C0187, C0188, C0189, C0190, C0191, C0192, C0193, C0194, C0195, C0196, C0197, C0198, C0199, C0200
World_of_Patterns/maths/Monoh/Poly4/d9/Part06 (40): C0201, C0202, C0203, C0204, C0205, C0206, C0207, C0208, C0209, C0210, C0211, C0212, C0213, C0214, C0215, C0216, C0217, C0218, C0219, C0220, C0221, C0222, C0223, C0224, C0225, C0226, C0227, C0228, C0229, C0230, C0231, C0232, C0233, C0234, C0235, C0236, C0237, C0238, C0239, C0240
World_of_Patterns/maths/Monoh/Poly4/d9/Part07 (40): C0241, C0242, C0243, C0244, C0245, C0246, C0247, C0248, C0249, C0250, C0251, C0252, C0253, C0254, C0255, C0256, C0257, C0258, C0259, C0260, C0261, C0262, C0263, C0264, C0265, C0266, C0267, C0268, C0269, C0270, C0271, C0272, C0273, C0274, C0275, C0276, C0277, C0278, C0279, C0280
World_of_Patterns/maths/Monoh/Poly4/d9/Part08 (40): C0281, C0282, C0283, C0284, C0285, C0286, C0287, C0288, C0289, C0290, C0291, C0292, C0293, C02094, C0295, C0296, C0297, C0298, C0299, C0300, C0301, C0302, C0303, C0304, C0305, C0306, C0307, C0308, C0309, C0310, C0311, C0312, C0313, C0314, C0315, C0316, C0317, C0318, C0319, C0320
World_of_Patterns/maths/Monoh/Poly4/d9/Part09 (40): C0321, C0322, C0323, C0324, C0325, C0326, C0327, C0328, C0329, C0330, C0331, C0332, C0333, C0334, C0335, C0336, C0337, C0338, C0339, C0340, C0341, C0342, C0343, C0344, C0345, C0346, C0347, C0348, C0349, C0350, C0351, C0352, C0353, C0354, C0355, C0356, C0357, C0358, C0359, C0360
World_of_Patterns/maths/Monoh/Poly4/d9/Part10 (40): C0361, C0362, C0363, C0364, C0365, C0366, C0367, C0368, C0369, C0370, C0371, C0372, C0373, C0374, C0375, C0376, C0377, C0378, C0379, C0380, C0381, C0382, C0383, C0384, C0385, C0386, C0387, C0388, C0389, C0390, C0391, C0392, C0393, C0394, C0395, C0396, C0397, C0398, C0399, C0400
World_of_Patterns/maths/Monoh/Poly4/d9/Part11 (40): C0401, C0402, C0403, C0404, C0405, C0406, C0407, C0408, C0409, C0410, C0411, C0412, C0413, C0414, C0415, C0416, C0417, C0418, C0419, C0420, C0421, C0422, C0423, C0424, C0425, C0426, C0427, C0428, C0429, C0430, C0431, C0432, C0433, C0434, C0435, C0436, C0437, C0438, C0439, C0440
World_of_Patterns/maths/Monoh/Poly4/d9/Part12 (40): C0441, C0442, C0443, C0444, C0445, C0446, C0447, C0448, C0449, C0450, C0451, C0452, C0453, C0454, C0455, C0456, C0457, C0458, C0459, C0460, C0461, C0462, C0463, C0464, C0465, C0466, C0467, C0468, C0469, C0470, C0471, C0472, C0473, C0474, C0475, C0476, C0477, C0478, C0479, C0480
World_of_Patterns/maths/Monoh/Poly4/d9/Part13 (40): C0481, C0482, C0483, C0484, C0485, C0486, C0487, C0488, C0489, C0490, C0491, C0492, C0493, C0494, C0495, C0496, C0497, C0498, C0499, C0500, C0501, C0502, C0503, C0504, C0505, C0506, C0507, C0508, C0509, C0510, C0511, C0512, C0513, C0514, C0515, C0516, C0517, C0518, C0519, C0520
World_of_Patterns/maths/Monoh/Poly4/d9/Part14 (40): C0521, C0522, C0523, C0524, C0525, C0526, C0527, C0528, C0529, C0530, C0531, C0532, C0533, C0534, C0535, C0536, C0537, C0538, C0539, C0540, C0541, C0542, C0543, C0544, C0545, C0546, C0547, C0548, C0549, C0550, C0551, C0552, C0553, C0554, C0555, C0556, C0557, C0558, C0559, C0560
World_of_Patterns/maths/Monoh/Poly4/d9/Part15 (40): C0561, C0562, C0563, C0564, C0565, C0566, C0567, C0568, C0569, C0570, C0571, C0572, C0573, C0574, C0575, C0576, C0577, C0578, C0579, C0580, C0581, C0582, C0583, C0584, C0585, C0586, C0587, C0588, C0589, C0590, C0591, C0592, C0593, C0594, C0595, C0596, C0597, C0598, C0599, C0600
World_of_Patterns/maths/Monoh/Poly4/d9/Part16 (40): C0601, C0602, C0603, C0604, C0605, C0606, C0607, C0608, C0609, C0610, C0611, C0612, C0613, C0614, C0615, C0616, C0617, C0618, C0619, C0620, C0621, C0622, C0623, C0624, C0625, C0626, C0627, C0628, C0629, C0630, C0631, C0632, C0633, C0634, C0635, C0636, C0637, C0638, C0639, C0640
World_of_Patterns/maths/Monoh/Poly4/d9/Part17 (40): C0641, C0642, C0643, C0644, C0645, C0646, C0647, C0648, C0649, C0650, C0651, C0652, C0653, C0654, C0655, C0656, C0657, C0658, C0659, C0660, C0661, C0662, C0663, C0664, C0665, C0666, C0667, C0668, C0669, C0670, C0671, C0672, C0673, C0674, C0675, C0676, C0677, C0678, C0679, C0680
World_of_Patterns/maths/Monoh/Poly4/d9/Part18 (40): C0681, C0682, C0683, C0684, C0685, C0686, C0687, C0688, C0689, C0690, C0691, C0692, C0693, C0694, C0695, C0696, C0697, C0698, C0699, C0700, C0701, C0702, C0703, C0704, C0705, C0706, C0707, C0708, C0709, C0710, C0711, C0712, C0713, C0714, C0715, C0716, C0717, C0718, C0719, C0720
World_of_Patterns/maths/Monoh/Poly4/d9/Part19 (40): C0721, C0722, C0723, C0724, C0725, C0726, C0727, C0728, C0729, C0730, C0731, C0732, C0733, C0734, C0735, C0736, C0737, C0738, C0739, C0740, C0741, C0742, C0743, C0744, C0745, C0746, C0747, C0748, C0749, C0750, C0751, C0752, C0753, C0754, C0755, C0756, C0757, C0758, C0759, C0760
World_of_Patterns/maths/Monoh/Poly4/d9/Part20 (40): C0761, C0762, C0763, C0764, C0765, C0766, C0767, C0768, C0769, C0770, C0771, C0772, C0773, C0774, C0775, C0776, C0777, C0778, C0779, C0780, C0781, C0782, C0783, C0784, C0785, C0786, C0787, C0788, C0789, C0790, C0791, C0792, C0793, C0794, C0795, C0796, C0797, C0798, C0799, C0800
World_of_Patterns/maths/Monoh/Poly4/d9/Part21 (40): C0801, C0802, C0803, C0804, C0805, C0806, C0807, C0808, C0809, C0810, C0811, C0812, C0813, C0814, C0815, C0816, C0817, C0818, C0819, C0820, C0821, C0822, C0823, C0824, C0825, C0826, C0827, C0828, C0829, C0830, C0831, C0832, C0833, C0834, C0835, C0836, C0837, C0838, C0839, C0840
World_of_Patterns/maths/Monoh/Poly4/d9/Part22 (40): C0841, C0842, C0843, C0844, C0845, C0846, C0847, C0848, C0849, C0850, C0851, C0852, C0853, C0854, C0855, C0856, C0857, C0858, C0859, C0860, C0861, C0862, C0863, C0864, C0865, C0866, C0867, C0868, C0869, C0870, C0871, C0872, C0873, C0874, C0875, C0876, C0877, C0878, C0879, C0880
World_of_Patterns/maths/Monoh/Poly4/d9/Part23 (40): C0881, C0882, C0883, C0884, C0885, C0886, C0887, C0888, C0889, C0890, C0891, C0892, C0893, C0894, C0895, C0896, C0897, C0898, C0899, C0900, C0901, C0902, C0903, C0904, C0905, C0906, C0907, C0908, C0909, C0910, C0911, C0912, C0913, C0914, C0915, C0916, C0917, C0918, C0919, C0920
World_of_Patterns/maths/Monoh/Poly4/d9/Part24 (40): C0921, C0922, C0923, C0924, C0925, C0926, C0927, C0928, C0929, C0930, C0931, C0932, C0933, C0934, C0935, C0936, C0937, C0938, C0939, C0940, C0941, C0942, C0943, C0944, C0945, C0946, C0947, C0948, C0949, C0950, C0951, C0952, C0953, C0954, C0955, C0956, C0957, C0958, C0959, C0960
World_of_Patterns/maths/Monoh/Poly4/d9/Part25 (40): C0961, C0962, C0963, C0964, C0965, C0966, C0967, C0968, C0969, C0970, C0971, C0972, C0973, C0974, C0975, C0976, C0977, C0978, C0979, C0980, C0981, C0982, C0983, C0984, C0985, C0986, C0987, C0988, C0989, C0990, C0991, C0992, C0993, C0994, C0995, C0996, C0997, C0998, C0999, C1000
World_of_Patterns/maths/Monoh/Poly4/d9/Part26 (40): C1001, C1002, C1003, C1004, C1005, C1006, C1007, C1008, C1009, C1010, C1011, C1012, C1013, C1014, C1015, C1016, C1017, C1018, C1019, C1020, C1021, C1022, C1023, C1024, C1025, C1026, C1027, C1028, C1029, C1030, C1031, C1032, C1033, C1034, C1035, C1036, C1037, C1038, C1039, C1040
World_of_Patterns/maths/Monoh/Poly4/d9/Part27 (40): C1041, C1042, C1043, C1044, C1045, C1046, C1047, C1048, C1049, C1050, C1051, C1052, C1053, C1054, C1055, C1056, C1057, C1058, C1059, C1060, C1061, C1062, C1063, C1064, C1065, C1066, C1067, C1068, C1069, C1070, C1071, C1072, C1073, C1074, C1075, C1076, C1077, C1078, C1079, C1080
World_of_Patterns/maths/Monoh/Poly4/d9/Part28 (40): C1081, C1082, C1083, C1084, C1085, C1086, C1087, C1088, C1089, C1090, C1091, C1092, C1093, C1094, C1095, C1096, C1097, C1098, C1099, C1100, C1101, C1102, C1103, C1104, C1105, C1106, C1107, C1108, C1109, C1110, C1111, C1112, C1113, C1114, C1115, C1116, C1117, C1118, C1119, C1120
World_of_Patterns/maths/Monoh/Poly4/d9/Part29 (40): C1121, C1122, C1123, C1124, C1125, C1126, C1127, C1128, C1129, C1130, C1131, C1132, C1133, C1134, C1135, C1136, C1137, C1138, C1139, C1140, C1141, C1142, C1143, C1144, C1145, C1146, C1147, C1148, C1149, C1150, C1151, C1152, C1153, C1154, C1155, C1156, C1157, C1158, C1159, C1160
World_of_Patterns/maths/Monoh/Poly4/d9/Part30 (40): C1161, C1162, C1163, C1164, C1165, C1166, C1167, C1168, C1169, C1170, C1171, C1172, C1173, C1174, C1175, C1176, C1177, C1178, C1179, C1180, C1181, C1182, C1183, C1184, C1185, C1186, C1187, C1188, C1189, C1190, C1191, C1192, C1193, C1194, C1195, C1196, C1197, C1198, C1199, C1200
World_of_Patterns/maths/Monoh/Poly4/d9/Part31 (40): C1201, C1202, C1203, C1204, C1205, C1206, C1207, C1208, C1209, C1210, C1211, C1212, C1213, C1214, C1215, C1216, C1217, C1218, C1219, C1220, C1221, C1222, C1223, C1224, C1225, C1226, C1227, C1228, C1229, C1230, C1231, C1232, C1233, C1234, C1235, C1236, C1237, C1238, C1239, C1240
World_of_Patterns/maths/Monoh/Poly4/d9/Part32 (8): C1241, C1242, C1243, C1244, C1245, C1246, C1247, C1248


1.3.7) Tilings formed by joining regular hexagons together

For one to three hexagons: World_of_Patterns/maths/Monoh/Poly6/Other/ (5): S1, S2, S3A, S3B, S3C
For four hexagons: Polyhexes: World_of_Patterns/maths/Monoh/Poly6/d4/ (7): C1, C2, C3, C4, C5, C6, C7
For five hexagons: Polyhexes: World_of_Patterns/maths/Monoh/Poly6/d5/ (22): C01, C02, C03, C04, C05, C06, C07, C08, C09, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19, C20, C21, C22
For six hexagons: (81)
Polyhexes (40): World_of_Patterns/maths/Monoh/Poly6/d6/Part1 : C001, C002, C003, C004, C005, C006, C007, C008, C009, C010, C011, C012, C013, C014, C015, C016, C017, C018, C019, C020, C021, C022, C023, C024, C025, C026, C027, C028, C029, C030, C031, C032, C033, C034, C035, C036, C037, C038, C039, C040
Polyhexes (41) World_of_Patterns/maths/Monoh/Poly6/d6/Part2 : C041, C042, C043, C044, C045, C046, C047, C048, C049, C050, C051, C052, C053, C054, C055, C056, C057, C058, C059, C060, C061, C062, C063, C064, C065, C066, C067, C068, C069, C070, C071, C072, C073, C074, C075, C076, C077, C078, C079, C080, C081
For seven hexagons (330)
Polyhexes: World_of_Patterns/maths/Monoh/Poly6/d7/Part1 (40): C001, C002, C003, C004, C005, C006, C007, C008, C009, C010, C011, C012, C013, C014, C015, C016, C017, C018, C019, C020, C021, C022, C023, C024, C025, C026, C027, C028, C029, C030, C031, C032, C033, C034, C035, C036, C037, C038, C039, C040
Polyhexes: World_of_Patterns/maths/Monoh/Poly6/d7/Part2 (40): C041, C042, C043, C044, C045, C046, C047, C048, C049, C050, C051, C052, C053, C054, C055, C056, C057, C058, C059, C060, C061, C062, C063, C064, C065, C066, C067, C068, C069, C070, C071, C072, C073, C074, C075, C076, C077, C078, C079, C080
Polyhexes: World_of_Patterns/maths/Monoh/Poly6/d7/Part3 (40): C081, C082, C083, C084, C085, C086, C087, C088, C089, C090, C091, C092, C093, C094, C095, C096, C097, C098, C099, C100, C101, C102, C103, C104, C105, C106, C107, C108, C109, C110, C111, C112, C113, C114, C115, C116, C117, C118, C119, C120
Polyhexes: World_of_Patterns/maths/Monoh/Poly6/d7/Part4 (40): C121, C122, C123, C124, C125, C126, C127, C128, C129, C130, C131, C132, C133, C134, C135, C136, C137, C138, C139, C140, C141, C142, C143, C144, C145, C146, C147, C148, C149, C150, C151, C152, C153, C154, C155, C156, C157, C158, C159, C160
Polyhexes: World_of_Patterns/maths/Monoh/Poly6/d7/Part5 (40): C161, C162, C163, C164, C165, C166, C167, C168, C169, C170, C171, C172, C173, C174, C175, C176, C177, C178, C179, C180, C181, C182, C183, C184, C185, C186, C187, C188, C189, C190, C191, C192, C193, C194, C195, C196, C197, C198, C199, C200
Polyhexes: World_of_Patterns/maths/Monoh/Poly6/d7/Part6 (40): C201, C202, C203, C204, C205, C206, C207, C208, C209, C210, C211, C212, C213, C214, C215, C216, C217, C218, C219, C220, C221, C222, C223, C224, C225, C226, C227, C228, C229, C230, C231, C232, C233, C234, C235, C236, C237, C238, C239, C240
Polyhexes: World_of_Patterns/maths/Monoh/Poly6/d7/Part7 (40): C241, C242, C243, C244, C245, C246, C247, C248, C249, C250, C251, C252, C253, C254, C255, C256, C257, C258, C259, C260, C261, C262, C263, C264, C265, C266, C267, C268, C269, C270, C271, C272, C273, C274, C275, C276, C277, C278, C279, C280
Polyhexes: World_of_Patterns/maths/Monoh/Poly6/d7/Part8 (40): C281, C282, C283, C284, C285, C286, C287, C288, C289, C290, C291, C292, C293, C2094, C295, C296, C297, C298, C299, C300, C301, C302, C303, C304, C305, C306, C307, C308, C309, C310, C311, C312, C313, C314, C315, C316, C317, C318, C319, C320
Polyhexes: World_of_Patterns/maths/Monoh/Poly6/d7/Part9 (10): C321, C322, C323, C324, C325, C326, C327, C328, C329, C330
Other Polyhexes: World_of_Patterns/maths/Monoh/Poly6/Other/ (7): C1, C2, C3, F901, F944A, F944B, F944C


1.3.8) Other convex monohedral tilings

World_of_Patterns/maths/Monoh/convex/ (16): F137, F1510B, F931AI, F931AN, F931BI, F931N1, F931N2, F932A, F932B, F932C, F932D, F932E, F932F, F932G, F932H, RS


1.3.9) Tilings having a central point

World_of_Patterns/maths/Monoh/Centred/ (20): A1, F123C, F136A, F136AA, F1510A, F1511B, F1511C, F1511D, F159A, F159B, F159C, F159D, G6A, G7A, H40, H41, S1, S2, S3, W1


1.3.10) For most single tiles which tile the plane, the same shape can tile the plane infinitely many ways. For some tiles, the number of ways is limited to 1, 2, etc up to a maximum of 12

N-morphic Tilings for n = 1, 2 or 3: World_of_Patterns/maths/Monoh/Nmorph/Part1 (12): F151A, F151B, F151C, F151D, F151H, F154A, F154B, F155A, F155B, F157B, F157C, F157D
N-morphic Tilings for n = 4 or more: World_of_Patterns/maths/Monoh/Nmorph/Part2 (48): F10C1, F10C10, F10C2, F10C3, F10C4, F10C5, F10C6, F10C7, F10C8, F10C9, F4C1, F4C2, F4C3, F4C4, F5C1, F5C2, F5C3, F5C4, F5C5, F6C1, F6C2, F6C3, F6C4, F6C5, F7C1, F7C2, F7C3, F7C4, F7C5, F7C6, F7C7, F8C1, F8C2, F8C3, F8C4, F8C5, F8C6, F8C7, F8C8, F9C1, F9C2, F9C3, F9C4, F9C5, F9C6, F9C7, F9C8, F9C9


1.3.11) Several beautiful patterns are made by tiling the plane in a spiral design

World_of_Patterns/maths/Monoh/spiral/ (27): AM1, F101, F12, F123B, F17, F18, F19, F20, F20A, F21, F5, F6, F951, F952A, F952B, F952C, F952D, F954A1, F954A2, F954A3, F954A4, F955, F956, F957, F958, N10, N5


1.3.12) Lastly, other shapes of mathematical interest are collected here, including those designed for their artistic effect

Other Monohedral Patterns: World_of_Patterns/maths/Monoh/Other/ (23): F128A, F128B, F129A, F129B, F129C, F129D, F129E, F129F, F129G, F129H, F138A, F138B, F138C, F152A, F152B, F324A, F6112A, F6112B, F6112C, F6112D, F6112E, PC1, PC2


Patterns defined by the symmetry classes of the vertices and tiles: Homeohedral Tilings

1.4.1) 2-homeohedral tilings: World_of_Patterns/maths/Homeo/TwoH/ (34): H2C01, H2C02, H2C03, H2C04, H2C05, H2C06, H2C07, H2C08, H2C09, H2C10, H2C11, H2C12, H2C13, H2C14, H2C15, H2C16, H2C17, H2C18, H2C19, H2C20, H2C21, H2C22, H2C23, H2C24, H2C25, H2C26, H2C27, H2C28, H2C29, H2C30, H2C31, H2C32, H2C33, H2C34


1.4.1) Other homeohedral tilings: World_of_Patterns/maths/Homeo/other/ (29): F01, F14A, F62A, F62B, F67C1, F67C10, F67C11, F67C12, F67C13, F67C14, F67C15, F67C16, F67C17, F67C18, F67C2, F67C3, F67C4, F67C5, F67C6, F67C7, F67C8, F67C9, F68MB, F68ML, F68MM, F68MR, F68TL, F68TM, F68TR


Other shapes of mathematical interest

1.5.1) Patterns made from polygons which can tile the plane in a limited number of ways (due to P Schmitt)

World_of_Patterns/maths/Other/Schmitt/ (14): F11, F17A, F17B, F17C, F17D, F17E, F17F, F17G, J5, JC, JD, JH, JS, JV


1.5.2) Monohedral tilings with regular vertices

World_of_Patterns/maths/Other/Laves/ (12): F3, F312, F346, F34A, F34B, F36A, F36B, F36C, F4, F4612, F48, F6


1.5.3) Tilings made only from infinite lines

World_of_Patterns/maths/Other/Straight/ (4): F1201A, F1201B, F1201C, F701


1.5.4) Tilings made from recursive defined patterns

World_of_Patterns/maths/Other/Recurse/ (5): FA14C1, FA14C2, FA16, FA22A, FA22C, FA24


1.5.5) Others

World_of_Patterns/maths/Other/Other/ (8): F1214A, F1214C, F323A, F323B, F341, F351, F352A, F352B


Artistic

Pre-Islamic

2.1.1) Roman

2.1.2) Celtic

2.1.3) Those collected by F M Hessemer (which actually covers Arabic and Italian sources)

2.1.4) Those collected by Carol Grafton (which actually later but are mainly in the Byzantine style)

2.1.5) Those collected by Robert Field from churches

2.1.6) Other earlier patterns


Islamic

2.2.1) J Bourgoin

2.2.2) I El-Said and A Parman

2.2.3) David Wade

2.2.4) S J Abas and A S Salman

2.2.5) Mirza Akber

2.2.6) The Iranian collection

2.2.7) Tilings with a grill design. These are mainly derived from window and door grills

2.2.8) Tilings from the Topkapi Roll

2.2.9) Tilings which are at two levels

2.2.10) Robert Field

2.2.11) Other sources


Post-Islamic

2.3.1) Quilt patterns

2.3.2) Lattice patterns

2.3.3) Other patterns


zurück zur Liste der Wettbewerbe zur Evolutionären Kunst