notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "hideCode": true,
    "hidePrompt": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "from math import sqrt\n",
    "\n",
    "from matplotlib import rcParams, pyplot as plt\n",
    "from matplotlib.path import Path\n",
    "from matplotlib.patches import PathPatch, Rectangle\n",
    "from matplotlib.transforms import Affine2D as T\n",
    "\n",
    "from svgpath2mpl import parse_path\n",
    "\n",
    "class Tile(object):\n",
    "    \n",
    "    def __init__(self, path = None):\n",
    "        self.bbox = True\n",
    "        if not path: path = Path([(0,0)])\n",
    "        self.path = path\n",
    "\n",
    "    @classmethod\n",
    "    def read(cls, name):\n",
    "        with open('{}.path'.format(name)) as _: \n",
    "            return cls(\n",
    "                parse_path(_.read()).transformed(\n",
    "                    T().scale(1, -1).translate(0, 1)\n",
    "                )\n",
    "            )\n",
    "            \n",
    "    @staticmethod\n",
    "    def union(tile0, tile1):\n",
    "        return Tile(Path.make_compound_path(tile0.path, tile1.path))\n",
    "            \n",
    "    @staticmethod\n",
    "    def transform(tile, transform):\n",
    "        return Tile(tile.path.transformed(transform))\n",
    "            \n",
    "    def _ipython_display_(self):\n",
    "        fig, ax = plt.subplots()\n",
    "        ax.add_patch(PathPatch(self.path, fill = False))\n",
    "        if self.bbox:\n",
    "            r = Rectangle((0,0), 1, 1, fill = False, linestyle = 'dotted')\n",
    "            ax.add_patch(r)\n",
    "        plt.axis('equal')\n",
    "        plt.axis('off')\n",
    "        return fig\n",
    "\n",
    "def flip(tile):\n",
    "    return Tile.transform(tile, T().scale(-1, 1).translate(1, 0))\n",
    "\n",
    "def rot(tile):\n",
    "    return Tile.transform(tile, T().rotate_deg(90).translate(1, 0))\n",
    "\n",
    "def rot45(tile):\n",
    "    return Tile.transform(tile,\n",
    "        T().rotate_deg(45).scale(1 / sqrt(2), 1 / sqrt(2)).translate(1 / 2, 1 / 2)\n",
    "    )\n",
    "\n",
    "def over(tile0, tile1):\n",
    "    return Tile.union(tile0, tile1)\n",
    "\n",
    "def beside(tile0, tile1, n = 1, m = 1):\n",
    "    den = n + m\n",
    "    return Tile.union(\n",
    "        Tile.transform(tile0, T().scale(n / den, 1)),\n",
    "        Tile.transform(tile1, T().scale(m / den, 1).translate(n / den, 0))\n",
    "    )\n",
    "\n",
    "def above(tile0, tile1, n = 1, m = 1):\n",
    "    den = n + m\n",
    "    return Tile.union(\n",
    "        Tile.transform(tile0, T().scale(1, n / den).translate(0, m / den)),\n",
    "        Tile.transform(tile1, T().scale(1, m / den))\n",
    "    )\n",
    "\n",
    "blank = Tile()\n",
    "f = Tile.read('f')\n",
    "fish = Tile.read('fish')\n",
    "edge = Tile.read('edge')\n",
    "triangle = Tile.read('triangle')\n",
    "\n",
    "rcParams['figure.figsize'] = 2,2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "# Programming with Escher\n",
    "\n",
    "This notebook is a collection of *preliminary notes* about a \"code camp\" (or a series of lectures) aimed at young students inspired by the fascinating [Functional Geometry](https://eprints.soton.ac.uk/257577/1/funcgeo2.pdf) paper of Peter Henderson.\n",
    "\n",
    "In such work the [Square Limit](https://www.wikiart.org/en/m-c-escher/square-limit) *woodcut* by [Maurits Cornelis Escher](https://en.wikipedia.org/wiki/M._C._Escher) is reconstructed from a set of *primitive* graphical objects suitably *composed* by means of a *functional language*.\n",
    "\n",
    "Here the approach will be somehow different: first of all because our recipients will be students new to computer science (instead of fellow researchers), but also because besides recalling the fundamental concepts of abstraction levels (and barriers), primitives and composition, present in the original paper, we will here also take the opportunity to introduce some (albeit to some extent elementary) considerations on algebra and geometry, programming and recursion (and perhaps discuss some implementation details).\n",
    "\n",
    "This work is to be considered *very preliminary*, it is not yet structured in a series of lectures, nor it is worked out the level at which every topic is to be presented, according to the age (or previous knowledge) of the students. The language and detail level used here is intended for instructors and teachers, and the various topics will be listed as mere hints, not yet as a viable and ready to use syllabus.\n",
    "\n",
    "As a last remark, before actually beginning with the notes, the code of this notebook is very loosely derived from previous \"implementations\" of Functional Geometry such as [Shashi Gowda](https://github.com/shashi)'s [Julia version](https://shashi.github.io/ijulia-notebooks/funcgeo/) and  [Micah Hahn](https://github.com/micahhahn)'s [Hasjell version](https://github.com/micahhahn/FunctionalGeometry) (containing the [Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) description of the Escher fish used here). I decided to rewrote such code in a [Jupyter](https://jupyter.org/) notebook written in [Python 3](https://www.python.org/), a simple and widespread language, to make it easier for instructors to adopt it.\n",
    "\n",
    "The [source notebook](https://github.com/mapio/programming-with-escher) is available on GitHub (under [GPL v3](https://www.gnu.org/licenses/gpl-3.0.en.html)), feel free to use [issues](https://github.com/mapio/programming-with-escher/issues) to point out errors, or to [fork it](https://help.github.com/articles/fork-a-repo/) to suggest edits.\n",
    "\n",
    "## Square Limit and tiles\n",
    "\n",
    "Looking at the original artwork it is evident that it is obtained by the repetition of a basic element (a fish) that is suitably oriented, scaled, and colored.\n",
    "\n",
    "![squarelimit](squarelimit.jpg)\n",
    "\n",
    "This suggest to start our journey from a **tile** (a set of lines enclosed in the unit square), that is a drawing building block, that we will manipulate to obtain more complex drawings.\n",
    "\n",
    "Note that, if one wants to follow an \"unplugged\" approach, tiles can be actually printed as objects so that students will be able to experiment with them in the physical world to better introduce themselves with the manipulations that will follow.\n",
    "\n",
    "It is a good idea to start with an asymmetric tile, that will make it easier to grasp the effect of the transformations that will be presented.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": true
   },
   "outputs": [],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "hideCode": false,
    "hidePrompt": true
   },
   "source": [
    "Observe that the dotted line is not part of the tile but serves only as a hint for the tile boundary, moreover tiles are implemented in a way that the notebook automatically draws them (without the need of explicit drawing instructions).\n",
    "\n",
    "## Transforming tiles\n",
    "\n",
    "We are now ready to introduce some **transformations**, namely `rot`  and `flip` that, respectively, rotate counterclockwise (by 90°) a tile, and flip it around its vertical center."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": true
   },
   "outputs": [],
   "source": [
    "rot(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "hideCode": false,
    "hidePrompt": true
   },
   "source": [
    "Observe that the notation is the usual one for *function* application, that should be immediately clear even to students new to programming (but with a basic understanding of mathematical notation). Of course one can *compose* such transformations insomuch function can be composed, that is performed one on the result of another.\n",
    "\n",
    "The first observation is that the *order* in which such transformation are performed can make a difference. Consider for instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flip(rot(f))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rot(flip(f))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second observation is that some choices, that can seem at first restrictive, can become less of a limitation thanks to composition: we can obtain clockwise rotations by applying three counterclockwise rotations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rot(rot(rot(f)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this can stimulate a discussion about the *expressiveness* or *completeness* of a set of *primitives* with respect to an assigned set of tasks.\n",
    "\n",
    "Then a few *binary* transformations (that is, transformation that operate on two tiles) can be introduced, such as: `above`, `beside` and `over`. The first two combine two tiles by juxtaposition (rescaling the final result so that it will again fit in a unit square), while the latter just lay one tile over another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beside(f, rot(f))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "above(flip(f), f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again one can observe that the order of the arguments is relevant, in the case of these two transformation, while it is not in the case of the latter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "over(f, flip(f))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic algebraic facts about transformations\n",
    "\n",
    "Such transformations can be also implemented as binary operators (thanks to Python ability to define classes that [emulate numeric types](https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types)); one can for instance use `|` and `/` respectively for `beside` and `above`, and `+` for `over`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "hideCode": true,
    "hidePrompt": true
   },
   "outputs": [],
   "source": [
    "class TileWithOperations(Tile):\n",
    "    @staticmethod\n",
    "    def addop(tile):\n",
    "        t = TileWithOperations()\n",
    "        t.path = tile.path\n",
    "        return t\n",
    "    def __add__(self, other):\n",
    "        return TileWithOperations.addop(over(self, other))\n",
    "    def __truediv__(self, other):\n",
    "        return TileWithOperations.addop(above(self, other))\n",
    "    def __or__(self, other):\n",
    "        return TileWithOperations.addop(beside(self, other))\n",
    "\n",
    "f = TileWithOperations.addop(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f / ( f | f )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will allow to investigate (with a natural syntax) basic algebraic structures as (*abelian* or not) *semigroups*, and even *monoids*, once a blank tile is been introduced, as well as more simple concepts as *associativity* and *commutativity*,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f + blank"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recursion\n",
    "\n",
    "It can be quite natural to introduce functions, initially presented as a sort of macros, to build derived operators. For instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def quartet(p, q, r, s):\n",
    "    return above(beside(p, q), beside(r, s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "is a new transformation, defined in terms of the previous one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quartet(flip(rot(rot(rot(f)))), rot(rot(rot(f))), rot(f), flip(rot(f)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then **recursion** can be introduced quite naturally to build tiles having self-similar parts. Let's use a triangle to obtain a more pleasing result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "triangle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's build a tile where the upper left quarter is a (rotated) triangle surrounded by three tiles similarly defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def rectri(n):\n",
    "    if n == 0: \n",
    "        return blank\n",
    "    else:\n",
    "        return quartet(rot(triangle), rectri(n - 1), rectri(n - 1), rectri(n - 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "developing the first four levels gives "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "rectri(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once can even push things further and show how to use of recursion instead of iteration, emphasizing how expressive a simple set of basic transformation, endowed with composition and recursion, can become."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extending the basic transformations\n",
    "\n",
    "What if we want to write `nonet`, a version of `quartet` that puts together nine tiles in a $3\\times 3$ arrangement? The given `beside` and `above` transformations are halving the width and height of the tiles they operate on, as it is easy to convince oneself, there is no way to use them to implement `nonet`.\n",
    "\n",
    "To overcome such limitation, one can extend those transformations so that one can specify also the relative sizes of the combined tiles. For instance, in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beside(flip(f), f, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the flipped `f` takes $2/5$ of the final tile, whereas `f` takes the other $3/5$. Using such extended transformations one can define"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def nonet(p, q, r, s, t, u, v, w, x):\n",
    "    return above(\n",
    "            beside(p, beside(q, r), 1, 2),\n",
    "            above(\n",
    "                beside(s, beside(t, u), 1, 2),\n",
    "                beside(v, beside(w, x), 1, 2), \n",
    "            ),\n",
    "            1, 2\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to obtain the desired result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nonet(\n",
    "    f, f,     f, \n",
    "    f, blank, f, \n",
    "    f, f,     f\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "of course, according to the way one decomposes the $3\\times 3$ tile as a combination of two sub-tiles, there are many alternative ways to define `nonet` that students can experiment with.\n",
    "\n",
    "Another possible approach will be to have `above`, `beside` (and `over`) accept a *variable number of arguments* (thanks to the way functions are [defined](https://docs.python.org/3/reference/compound_stmts.html#function) and [called](https://docs.python.org/3/reference/expressions.html#calls) in Python). In such case, otaining the `nonet` will be trivial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decomposing the woodcut\n",
    "\n",
    "The basic building block of the woodcut is a fish"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "hideCode": true,
    "hidePrompt": true
   },
   "outputs": [],
   "source": [
    "rcParams['figure.figsize'] = 4, 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fish"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "even if it is not completely contained in a tile (the unit square), Escher choose (we'll discuss such magic in the following) a shape able to fit with his own rotation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "over(fish,rot(rot(fish)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But this is not the only magic. Let's define a new transformation that is a 45° rotation and a rescaling (by a $\\sqrt 2$ factor) that, somehow, will \"lift up\" half tile; using it on `triangle` should clarify its definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rot45(triangle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, the fish is so magic that if we transform it with such new rotation and `flip` it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "smallfish = flip(rot45(fish))\n",
    "smallfish"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we obtain a new tile that will fit with the original `fish`, even if rotated again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "t = over(fish, over(smallfish, rot(rot(rot(smallfish)))))\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and will moreover fit with itself however rotated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "u = over(over(over(smallfish, rot(smallfish)), rot(rot(smallfish))), rot(rot(rot(smallfish))))\n",
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `t` and `u` tiles just defined are the building blocks of the woodcut; a recursive definition of the side, based just on `t` is given by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def side(n):\n",
    "    if n == 0: \n",
    "        return blank\n",
    "    else: \n",
    "        return quartet(side(n-1), side(n-1), rot(t), t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expanding the first two levels gives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "side(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, a recursive definition of the corner, based on the `side` and `u` is given by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def corner(n):\n",
    "    if n == 0:\n",
    "        return blank\n",
    "    else:\n",
    "        return quartet(corner(n-1), side(n-1), rot(side(n-1)), u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before, the first two levels are"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "corner(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now can use a `nonet`  to put together the (suitably rotated) sides and corners, as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def squarelimit(n):\n",
    "    return nonet(\n",
    "        corner(n), \n",
    "        side(n), \n",
    "        rot(rot(rot(corner(n)))), \n",
    "        rot(side(n)), \n",
    "        u, \n",
    "        rot(rot(rot(side(n)))),\n",
    "        rot(corner(n)), \n",
    "        rot(rot(side(n))), \n",
    "        rot(rot(corner(n)))\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expanding the first three levels gives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "hideCode": true,
    "hidePrompt": true
   },
   "outputs": [],
   "source": [
    "rcParams['figure.figsize'] = 20, 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "squarelimit(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The magic fish\n",
    "\n",
    "What is actually even more magic is that (the outline) of the fish, that makes it fit with himself in so many ways, can be obtained just from a simple line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "hideCode": true,
    "hidePrompt": true
   },
   "outputs": [],
   "source": [
    "rcParams['figure.figsize'] = 4, 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "edge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this can be duplicated and transformed with `rot45` to obtain the left side of the fish"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "outline2 = over(\n",
    "    rot45(flip(rot(edge))),\n",
    "    rot(rot(rot45(flip(rot(edge)))))\n",
    ")\n",
    "outline2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to obtain the other side of the fish we need to rotate the `edge` and to translate it outside of the boundary of the tile… this can't be accomplished with the basic transformations we introduced above, but more directly as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "outline3 = Tile.transform(rot(edge), T().translate(-1,0))\n",
    "outline3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we are now ready to put together the three edges to obtain the fish"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "outline = over(edge, Tile.union(outline3, outline2))\n",
    "outline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the role of the basic `edge` can become more clear if we add the `triangle` tile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "over(triangle, outline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By drawing the `squarelimit` using the `triangle` as a basic tile helps understanding the magic of how the tiles fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "hideCode": true,
    "hidePrompt": true
   },
   "outputs": [],
   "source": [
    "def _t(base):\n",
    "    t2 = flip(rot45(base))\n",
    "    t3 = rot(rot(rot(t2)))\n",
    "    return over(base, over(t2, t3))\n",
    "\n",
    "def _u(base):\n",
    "    t2 = flip(rot45(base))\n",
    "    return over(over(t2, rot(t2)), over(rot(rot(t2)), rot(rot(rot(t2)))))\n",
    "\n",
    "t = _t(triangle)\n",
    "u = _u(triangle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "squarelimit(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perhaps even better if we use the `outline`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "hideCode": true,
    "hidePrompt": true
   },
   "outputs": [],
   "source": [
    "t = _t(outline)\n",
    "u = _u(outline)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "squarelimit(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementation notes\n",
    "\n",
    "Implementing the above primitives can be done in so many ways, that is hard to argue which will be the better.\n",
    "\n",
    "Here all the drawing is made using [Matplotlib](https://matplotlib.org), probably the most common Python plotting library; few details of our implementation are:\n",
    "\n",
    "* the [matplotlib.path.Path](https://matplotlib.org/api/path_api.html#matplotlib.path.Path), that \"represents a series of possibly disconnected, possibly closed, line and curve segments\" is used as a basic building block for tiles;\n",
    "\n",
    "* such paths can be easily *transformed* using [matplotlib.transforms.Affine2D](https://matplotlib.org/api/transformations.html#matplotlib.transforms.Affine2D) that very conveniently perform scaling and translations;\n",
    "\n",
    "* once the path with the desired shape is obtained, it can be turned in a [matplotlib.patches.PathPatch](https://matplotlib.org/api/patches_api.html#matplotlib.patches.PathPatch) that can be straightforwardly rendered by [matplotlib.axes.Axes.add_patch](https://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.add_patch.html).\n",
    "\n",
    "Of course, instead of using the Matplotlib code for transformation one can take the opportunity to introduce more in detail the *affine transformations*, providing a simple \"hand made\" implementation.s"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Hide code",
  "hide_code_all_hidden": true,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}