This inspired me to revisit my old work on Conway Polyhedron Operators. I’ve had a couple of (unpublished) attempts to implement these in Blender’s Geometry Nodes, but was limited by the lack of a mesh bevel node (and my skill level).

Conway Polyhedra are formed by applying various operators to a seed polyhedron such as one of the platonic solids. Some of these are the same as nodes already available , for example, the ortho operator is the same as the Subdivide Mesh Node with Level set to 1. Other operators are easily done in edit mode, for example, the kis operator is the same as Poke Faces on the Face menu.

For an overview of the operators see wikipedia To play online with the operators see either polyhédronisme or George Hart. I’ve implemented most of the Conway Operators in a blend file available on GitHub. All the useful node groups are marked as assets and will be available in the asset browser if you save the blend file on an asset library path. ( for example ~/Documents/Blender/Assets)

In this post, rather than go into detail on every node group, I’m going to give an overview of the groups I’ve made. I hope to follow up with some posts grouped on topic rather than node group. I have a post planned on evaluating attributes across domains, and another on debugging and testing strategies.

Conway assets

The blend file contains sixteen operators

There’s also a bunch of seed polyhedra and seed tiles to combine with the operators.

These are simple to construct but its useful to have them easily accessible with a unit radius.

All the operators also work on 2D mesh tilings. There’s a node group for triangles, squares and hexagons. These are approximately 2 m by 2 m and centred at the origin.

Each of the above sets of nodes has an overall node with a drop down menu to quickly switch between operators or between seeds. This is quicker for experimenting with combining operators than rewiring nodes.

To use these nodes combine a seed with a few operators. For example:

If implementing a polyhedra in Conway notation, be aware that the notation and node order is reversed. That is, enter wgD on polyHédronisme to get the polyhedron above.

Each of these subdivided polyhedra has a standard or canonical form. This form has all faces planar and all edges tangential to the unit sphere. The centre of the vertices of the polyhedra should also be at the origin.

The canon node does this. It has two inputs Iterations and scale. Applying it makes the polyhedron smoother and more symmetrical.

Increase the Iterations , and maybe the scale until the polyhedron smooths out. The canon algorithm makes scale sized improvement in Iterations number of steps. Too large a scale value will blow the polyhedron up into a mess.

Here is a gif of the each iteration of the canon node on qoD (a Dodecahedron with an ortho operator followed by a quinto operator) .

The canon operator is applied a few seconds into the animation. The sphere inflates quickly to near the unit sphere, than takes a lot more iterations to rotate the smaller quads until the edges connecting them become tangent to the unit sphere.

All the operator nodes work equally well on 2D tilings. Trying an operator on a 2D mesh often helps in understanding what it does

This is gyro-whirl applied to the tri-tile grid.

Or gyro-whirl on a hyperbolic tiling

Part 1
Part 2
blend file

So far I made a tiling of the Poincaré Disk, but for simplicity I drew the tiling edges with straight lines. The edges in the tilings should really be arcs because in Poincaré geometry the shortest distance between two points is a geodesics or circle arc.

I found it easiest to replace the edges after constructing the tiling. I used two nested “For Element “ loops. The outer one iterates over every face in the tiling, the inner one over every edge in the face. This duplicates calculations but it’s fast enough, so no optimisation needed.

Inner loop

The inner loop is simple and just creates a HypSegment through the two points of each edge on the face.

Outer Loop

The outer loop (optionally) fills the curve with an n-gon. The Curve to Mesh ` Merge by Distance Mesh to Curve` node sequence, merges the extra vertices at the face corners and sorts the vertices into sequential order. After that we replace the curves with a filled mesh circle with the appropriate number of vertices, then set the vertex position to that sampled from the curve.

The full node group p-tiling-arc-option in the available blend file. has some other draw options.

geodesics draws a full HypLine between the ideal points on the edge of the Poincaré Disk (the unit circle) for every edge.

The off centre options allow the polygon that starts the tiling to be displaced from the origin. Setting this up involved creating some more basic tools for working with hyperbolic geometry.

• h-distance- the length of the geodesic between two points
• h-circle - the euclidean centre and radius of a hyperbolic circle.

h-distance

The hyperbolic distance is the shortest distance between two points in the Poincaré Disk. A derivation is given here - GCT Measurement in Hyperbolic Geometry that doesn’t require finding the ideal points of the geodesic. The result there is given in complex number notation.

\(d_H(p, q) = |\ln{(\frac{|1-\overline{p}q|+|q-p|}{|1-\overline{p}q|-|q-p|})}|\) where $p =p_x +ip_y$ and $q= q_x +iq_y$ are complex numbers and $\overline{p} =p_x -ip_y$ is the complex conjugate of $p$ swapping to vector notation $P=(p_x, p_y)$ and $Q=(q_x, q_y)$,

\(\overline{p}q = (P\cdot Q, |P \times Q|)\) $P\cdot Q$ is the dot product and $|P\times Q|$ is the length of the cross product. or in math formula extension notation

ng h_distance(P: vec3, Q:vec3) -> hd: float{
	qp = dist(P,Q);
	ccpq = length({1 - dot(P, Q),length(cross(P, Q)),0});
	out hd = abs(log((ccpq + qp)/(ccpq - qp), #e));
}
h_distance({0.5, 0, 0}, {0, 0.5, 0});

h-circle

For a hyperbolic circle all the points are an equal hyperbolic distance from the hyperbolic centre. It can be drawn as an Euclidean circle with the Euclidean centre $B_E$ offset from the hyperbolic centre $B$ on a line toward the origin $O$.

Distances from a point to the the origin of the Poincaré Disk can be converted back and forth from hyperbolic $d_H$ to Euclidean $d_E$ distances via

\(d_H=|ln(\frac{1+d_E}{1-d_E})|\) \(d_H = 2 \tanh^{-1} d_E\)

and \(d_E = \tanh(\frac{d_H}{2})\)

where $\tanh$ is the hyperbolic tangent function.

Using this we can find he Euclidean centre $B_E$ of a hyperbolic circle, centre at $B$, through $A$

\(r_H = d_H(\overline{A},\overline{B})\) \(b_H = d_H(\overline{B},\overline{O})\)

Now I have the h-circle group, I can use it to find the perpendicular bisector geodesic of the desired centre of a hyperbolic polygon and the origin. then I reflect a polygon at the origin through this geodesic to place the vertices of the off centre polygon.

The hyperbolic perpendicular bisector construction is analogous to the familiar Euclidean one. Draw a circle centred on A through B, and another circle centred on B through A. Find the two intersections points of these circles. Draw a line though them.

And the full off-center-polygon group

This is incorporated into the p-tiling group,within the p-tiling-arc-option to produce Poincaré tilings with an off centre polygon.

The off-center-polygon can also be used to draw other patterns.

Here a hyperbolic line is drawn through the centre and each vertex of a polygon.

So that wraps this series for now. Although I have some ideas for hyperbolic solids in 3D …

All the hyperbolic tools can be found as assets in the provided blend file. Most of the pretty pictures are available in the “demos” collection in that file. There’s also a “tests” collection, that has tests for the h-circle and h-distance groups. I needed to rewrite these two groups as I refined and simplified the maths. I wanted to find a way to use tests in a similar way that I would use with text code. I think this works.

Overall, this was a great learning exercise. I’ve improved my ability to implement maths and geometry in Blender Geometry Nodes heaps. I feel I’ve got my fingers over the edge of the learning cliff and can now pull myself up. Hopefully, I’ll document some more of this here on the blog.

Circle Inversion

The next maths step is finding the reflection of a point in the geodesic. Inversive geometry - Wikipedia

In the above diagram $D^\prime$ is the point $D$ reflected in the arc-line circle. $D^\prime$ lies on the line $CD$, where $C$ is the centre of the arc-line circle (coordinates $(x_0, y_0)$). The inversion position of this point along the line is defined such that :

or in coordinate geometry:

\(m = \frac{r^2}{(x-x_0)^2 + (y-y_0)^2}\)\(x^\prime = x_0 + m(x-x_0)\) \(y^\prime=y_0+m(y-y_0)\) or in math formula extension syntax:

ng reflect_point_circle(point:vec3, center:vec3, radius:float)-> reflect_point:vec3 { 
 m = radius**2.0/(dist(point, center)**2.0);
 d = sub(point, center);
 out reflect_point = center + scale(d, m);
 }
 reflect_point_circle({0.5, 0.5, 0.0}, {0.,0.,0.}, 1.0);

I end up with this node group.

Check this by drawing a diagram similar to the GeoGebra one above.

Mirror a single face in the edge of a polygon

Next lets mirror an entire face in the circle.

The smallest 7-gon is the mirror image of the central 7-gon in one of its edges using circle inversion. For comparison, the euclidean reflection is also shown.

Calculate the size of the central polygon

The central polygon of a hyperbolic tiling must have a specific radius $d$ depending on $p$ the number of vertices of each polygon, and $q$ the number of polygons (or edges) meeting at each vertex.

see Non-Euclidean Geometry: Interactive Hyperbolic Tiling in the Poincaré Disc for a derivation of this.

Math formula extension syntax

ng radius_center_n_gon(p:int, q:int) -> euclidean_radius: float {
	tq=tan(#(pi/2)-#pi/q);
	tp=tan(#pi/p);
	out euclidean_radius = sqrt((tq-tp)/(tq+tp));
}
radius_center_n_gon(7, 3);

Mirror the adjacent face for all boundary edges

Next I wrap this up as a group that loops over all boundary edges, finds the adjacent face and reflects it in the edge.

Tiling

Combining all these steps to create a tiling of the Poincaré Disk. Recap Groups created - names as in the accompanying blend file.

• “geodesic” - find the centre and radius of the geodesic through two points on the Poincaré Plane
• “reflect-point-circle” - find the position of a point mirrored in a geodesic
• “radius-center-n-gon”
• “mirror-adjacent-faces-poincare” - mirror - the adjacent face for all boundary edges

For ease, the edges of the polygons are plotted as a straight lines. They should, of course, be arcs. I’ll look at replacing the edges with geodesic segments in Part 3 of this series. In that post I’ll also show how to move the start polygon away from the centre.

Subdividing tiling

Lots of fun can be had by adding triangulate, dual, and subdivide nodes to the tiling output.

This is related to Conway Operators which is another thing I’ve been playing with in Geometry Nodes. I’ll write it up here eventually.

My learning strategy was to make a list of all the available nodes and work through them in groups (for example, all the mesh topology nodes) and make a trivial or simple node example for each. Currently I’ve done about 40% of the nodes in Blender 5.1. I might tidy this up and share at some point.

I mixed the node by node examples with trying to develop problems to solve that interested me. Watching endless rounds of you-tube videos, wire this node to that node, didn’t work for me.

I previously created Poincaré tilings in Sverchok way back in 2015. Then I was mostly interested in producing a 3D model of the hyperbolic plane by unfurling the tiling using Processing.

I was absolutely stoked when an image from the original blog was used on the cover of the journal “For the Learning of Mathematics” (Vol 39, No 1 (2019)). The issue included an article recalling the late David W. Henderson a mathematician who did extensive work alongside his wife Daina Taimina on the topology of hyperbolic planes.

This time, I’ll start by creating some node groups to do the basics such as drawing lines and circles and calculating distance in the Poincaré disc model. Then I’ll combine them to draw some pretty patterns including tilings.

All the node groups are available as assets in a blend file . Refer to them if the screenshots I use below are a bit small.

I started an unpublished version of this post that had a lot of maths and derivations. This version I’m mostly going to quote the formula for each node group and give a reference to more detail.

What is the Poincaré disk?

A Euclidean plane is flat (zero curvature) and can be tiled with 6 hexagons surrounding a central hexagon. If you put 5 hexagons around a pentagon you get a sphere (positive curvature) like a soccer ball. If you put 7 hexagons around a heptagon (7 sided p-polygon) you get a hyperbolic plane with negative curvature everywhere. I describe it better (with pictures) in Blender Adventures with Hyperbolic Planes

The Poincaré disk is a model of the wrinkly 3D surface of a hyperbolic plane drawn flat on a 2D unit disk. All points on the hyperbolic plane are mapped on to a 2D disc with a radius of 1.

To get a feel for the weird geometry where straight lines are circular arcs have a play in the interactive tilings at Non-Euclidean Geometry: Interactive Hyperbolic Tiling in the Poincaré Disc and Make Hyperbolic Tilings of Images

Basic Tools

I’ve divided this post into three parts. The node groups I’ll describe in each post (blend file) are shown here.

These are all available as assets in the blend file.

geodesic node group

The first step in creating a tiling on the Poincaré Disk, is to draw a line (called a geodesic) through two points. In this non-euclidean geometry this is a circle arc that goes through the two points $(a_x, a_y)$, $(b_x, b_y)$ and is perpendicular to the unit circle at the edge of the disk. If the geodesic goes through the origin, its a straight line diameter.

The geodesic node group returns the Euclidean centre and radius of the geodesic through two points, input as 3D vectors. If the two points are on a diameter the Is diameter? output is true, In this case, the centre is set to (0.0, 0.0, 0.0) and the radius is large. The centre and radius are in Euclidean space so can be used to draw lines and segments (see HypLine and HypSegment groups)

For all these node groups be sure to keep the z-component of the input vectors set to 0.0. The nodes internally use maths that assumes this.

The formulae for the Euclidean centre $(e_x, e_y)$ and radius $r$ are: \(e_x = -\frac{1}{2}\frac{a_y(b_x^{2}+b_y^{2} + 1) - b_y(a_x^{2}+a_y^{2} +1)}{a_x b_y-a_y b_x}\)

\(e_y = -\frac{1}{2}\frac{b_x(a_x^{2}+a_y^{2} + 1) - a_x(b_x^{2}+b_y^{2} +1)}{a_x b_y-a_y b_x}\) \(r=\sqrt{e_x^{2}+e_y^{2}-1}\)

These can be worked out from the formulae in the “By Analytical Geometry” section of the wikipedia artice on the Poincaré disk model.

Noding this up is prone to errors (as is typing in the Latex here). For the noding I used the Math Formula extension, which I highly recommend.

Use the shortcut ALT-F and copy paste the following.

ng geodesic(v1: vec3, v2: vec3) -> center:vec3, radius: float, IsDiameter: bool {
 ax, ay, _ = separate_xyz(v1);
 bx, by, _ = separate_xyz(v2);
 cx, cy, c = cross(v1, v2);
 sv1 = length(v1)**2.0+1.0;
 sv2 = length(v2)**2.0+1.0;
 ex = -0.5*(ay*sv2-by*sv1)/c;
 ey = -0.5*(bx*sv1-ax*sv2)/c;
 r = sqrt(ex**2.0 + ey**2.0 -1.0);
 out center = {ex, ey, 0.0};
 out radius = r;
 out IsDiameter = c == 0;
}
geodesic({0.5,0.,0.}, {0.,0.5,0.});

On hitting CTRL-ENTER you should magically get a new node group with ~ 27 nodes.

The Math Formula is a life saver for this kind of complicated maths.

Drawing geodesics

To draw the geodesic, The simplest is to translate a Mesh Circle using the center output of the geodesic node and scale using the radius output.

Moving the x, y coordinates of the line start and end should move the arc around. It should always be through the two points and cross the unit circle at right angles.

To draw a geodesic just between the two points I’ll use the Arc curve node.

arc-mid-point node group

The “Arc” node (in Points mode) needs a mid point on the arc. I need to find Point E in the diagram below.

Some vector maths gives us:

\(\overline{OD} = \frac{\overline{OA} + \overline{OB}}{2}\) \(\overline{OE} = \overline{OC} - \frac{\overline{OC}-\overline{OD}}{\Vert \overline{OC}-\overline{OD} \Vert} r\) or as a node group - arc-mid-point

HypSegment node group

circle-circle-intersection node group

A full line on the Poincaré plane should start and end on the unit circle. To draw this, I need to find the two intersection points of the circle given by the geodesic node group and the unit circle. These are called the ideal points of the geodesic.

I made a node group for the intersection of any two circles as it will be useful later.

Here’s the math formula extension notation for that node group. The derivation can be found here for example. The symbols in the diagram match the code, uppercase for vectors, lowercase for scalars.

ng circle_circle_intersection(A:vec3,ra:float, B:vec3, rb:float) -> P1:vec3, P2:vec3, IsIntersecting: bool {
	d = dist(A, B);
	U = normalize(B-A);
	V = cross(U, {0.,0.,-1.});
	f = (ra**2.0 - rb**2.0 + d**2.0) / (2*d);
	G = A + scale(U, f);
	H = scale(V, sqrt(ra**2.0 - f**2.0));
	out P1 = G + H;
	out P2 = G - H;
	
	sr = ra + rb;
	mr = abs(ra - rb);
	out IsIntersecting = boolean_math_nor(d < mr, d > sr);
	}
circle_circle_intersection({0.,0.,0.}, 2., {1.,0.,0.}, 1.);

HypLine node group

This is similar to the HypSegment node group with the addition of the circle-circle-intersection group.

Pretty Pictures

To end this post lets draw the geometry for the header image. First connect one point of a mesh circle to all the others via a HypLine.

If we then instance this pattern on every point, we’ll double up a lot of curves, which show as texture artefacts when I convert the curves to a tube.

There are a couple of different ways to do this. Only draw half the lines in the for each element loop, then instance that on all points.

Or put a repeat zone around the for element zone

The blend file for this post is available.

Next post, I’ll cover circle inversion or mirroring across the geodesic leading to hyperbolic tilings.

The fence post was water blasted and then sanded back to bare clean wood. I then used stains and paint to approximate how it looked outside. The cracks and divots have been emphasised with a black stain. It’s really more solid than it looks.

For the concrete base, I dug a few buckets of gravel and sand from the creek down the back. There’s also a nice seam of plastic clay in the creek bed so I hauled back a couple of buckets of that as well.

I turned the chair base upside down and used the clay to create a mould to pour the concrete. The dowels are to create holes to bolt the base to the chair. I pressed the larger stones into the clay to form the pattern on the top. Many of the stones were not held well when the concrete set but I still like the pattern. Being that type of person, I did make a mock up in Blender and use the 3D print add-on to check the volume was going to be about right. But then in making it was a lot more like mud pies than precision. The clay was so nice, it makes me want to get friendly with a local potter just to see what temperature it might fire at (can’t keep an old potter out of the mud…).

The top of the concrete ( or the bottom when its up the right way) was pretty rough so I cut a decagon out of plywood and painted it black. The ply is bolted to the chair base with the concrete sandwiched in the middle. There’s lots of cut up bike inner tube between the ply and the concrete to spread the load a bit.

Here’s some details of the staining and painting. I used a coarse sand gel paint medium to get the gritty lichen texture.

The band of green paint has a crackle medium under it, but I don’t think I put it on thick enough as it’ didn’t come out as strong as I’d like. A bit of work with some sandpaper gave the worn look I was after.

And here it is in use. The monitors, laptop, keyboard and tablet are all held in place on the post via standard office workstation components.

The arms are all adjustable and the desk can be used sitting as above, or standing as below.

You can see i have a cable management problem and I’ve got some bits ordered to help tidy that up. The two monitors can be switched individually between the laptop (work) and the large CPU (graphics etc.) via a couple of HDMI switches. I’m going to mount a single PD power supply that will power both monitors and the laptop.

The whole rig is designed to be easily portable. I can work in the back office watching the bell-birds on the fuchsia outside the window, or in front of the fire in winter or under the air-con in summer.

I’m really pleased with this, its of the land of our new rural block. Its really stable and best of all there are no flat surfaces to accumulate paper. Just a bin in the corner for filing.

Last week, I planted seeds for this year’s summer crops. Chillies, tomatoes, cucumbers, rock melons, and pepinos. This is a week or two earlier than last year, but they’ll go into the glasshouse until after the last frost.

For now they’re all germinating inside in an old aquarium in front of the glass sliding doors. I put the electric heating pad on overnight to keep them happy.

Last year, one of my first-time-can-I-grow-it-here crops was eggplants . The long skinny Asian variety. The seed website said “violet-pink fruit” but some of my plants had white fruit. No idea. I grew them in the glasshouse and they did OK, but a few pesky caterpillars and lots of whitefly.

This year I’m trying rock melons. I’m probably being a bit cocky but we’ll see.

I’ve planted heaps more chillies, they were really successful last year. Some of the plants were 2nd year although all the plant catalogues say they’re annuals. I’ve left them to over-winter and will see how they do. Black mould is a definite problem. The new chilli seeds this year are all hot varieties - Asian FIre, Carolina Reaper, Bhut Jolokia, Thai Hot and Habanero. That should have us panting.

But for now the snow is pretty cool.

I mainly wanted somewhere to share some of my photography away from any of the social media sites. I’ve also collected up some albums up of my old clay sculptures (dormant deviant art profile) and some digital art that’s also on (ArtStation).

The gallery deployment needs to be really low effort for me to (hopefully- good intentions) keep updating it. I looked at some nice jekyll themes (photorama, starving-artist, photography) but settled instead on thumbsup a standalone static HTML generator.

The gallery is deployed using the workflow from github-pages-gallery to setup github actions to host it directly on Github pages.

The theme is adapted from one by langurmonkey, with a bit of styling to match this blog.

Adding new photos is as simple as:

• copy files into folders/albums in the local git repository for https://github.com/elfnor/elfnor-gallery
• (optional) add a description via the comment button in gthumb or similar.
• (optional) run docker run -v "$(pwd):/work" ghcr.io/thumbsup/thumbsup /bin/sh -c "cd /work/ && thumbsup --config config.json" to build locally
• add-commit-push to Github
• DONE!

There’s a few things I’d like to improve:

• the description banner is a bit intrusive
• and I’d like longer descriptions for some of the artworks - could I reuse the right-hand panel designed for exif info?
• match the styling a little closer to the blog.
• do I want to strip (some/all) exif data? Or show it?

After scanning lots of stuff, I wanted to do something with it. This piece is a quick kit-bash where the main landforms are from a photogrammetry scan of a rock on a local beach. The original rock is about knee high. The tower is based on a ceramic model I made some years ago. I thought about making a photogrammetry model of it as well, but modelled it directly in Blender as I made some significant changes.

Click to see full size image.

The water is via the True Terrain add-on.

I was after a slight painterly effect so used the low sample count and denoise trick. The image is only rendered with 32 samples but using the OpenImageDenoise smooths this out to the final non-realistic look. The advantages of this are speed, and less need for excessive texture detail. I could have also considered using the denoise in the compositor and only applying to some parts of the image.

I also played around a bit with post processing with G’MIC filters in Krita to go even more toward a painterly style. This is really easy to overdo. My process is to make a duplicate layer of the original, above the background layer, apply the filter to the duplicate, then reduce the opacity of the duplicate layer until the effect is just there. To record the current state, a new layer can be created from the visible layers (right click in layer panel -> New Layer From Visible). This new layer can then be duplicated, a filter applied and the opacity adjusted as before. Adding the original layer back on top of the layer stack with low opacity (possibly with a colour LUT) can bring back some lost detail or colour. This process give a dynamic workflow with the G’MIC filters.

Mouse over the image to see the original with no G’MIC filters. The filters used are Black & White - Pencil, Artistic - Dream Smoothing and Colors - Color Presets - LUTs Pack PIXLS.US - Modern Film.

I tend to make a lot of duplicate layers, each with single filter. I name each layer after the filter. Then fiddle. It helps to have an example or a clear idea of the style you’re aiming for. Otherwise the fiddling can lack direction and not result in much improvement.

Another approach is to filter the images used in the textures before rendering. This has a lot longer feedback time, but can be effective. Each filter layer can be exported separately and then combined in the Shader editor in Blender. This give more control over the strength of each filter. Bolder filters work well for NPR effects.

For example, in Krita I applied a G’MIC Dream Smooth and a Sketch filter to the main rock texture image.

And here’s the original rock on location at the local beach.

I scanned and used the line art to practice with the colorize mask in Krita. David Revoy’s tutorial is great for this.

I enjoyed working in 2D and thought I’d build the basic rock and building outlines in Blender and go back to Krita for another paint over. But I must be more a 3D than a 2D artist, because I couldn’t stop and modelled everything in Blender. This included modelling a plausible back half to the island. Many times I thought I couldn’t match the 3D geometry to the 2D sketch, but the concept artist is also a mechanical engineer and I always found a solution that made sense within his world.

Video

I put the video (and the stills) through a G’MIC LUT filter (PIXL.US Modern Film at 50% strength). This post here about how to extract the commands from GIMP (I did this in Krita instead) was very useful.

The commands for G’MIC 2.9.8 look different from the version used tutorial but I ended up with the following bash script to run over all the rendered stills from Blender

#!/bin/bash
mkdir ./done
for i in *png
do
gmic $i -fx_color_presets 19,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,15,1,1,1,1,1,1,512,50,0,0,0,0,0,0,0,50,50,"0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0" -o ./done/$i
done

Music

I haven’t worked much with music tracks for video, but I wanted a 25 second clip that would loop seamlessly if the fly-around was played continuously. I initially tried doing this with an mp3 track but I couldn’t get the bars and phrasing to match the length.

I then tried starting with a midi track. Within LMMS it was easy to identify an 8 bar phrase in my chosen track that would loop well. Cutting just that bit out of the rest of the midi in LMMS seemed harder than it should be. I ended up finding that the export as wav option could be set to only export the part between the loop markers. I then brought the wav into Audacity and used Effect-> Change Speed to make it exactly 25 seconds long.

Overall this was a fun project that took a lot longer than techmonkey took to make that original concept sketch.

I have little idea how ligatures and fonts work, but I could get this all going fairly simply. I’ll detail my exploration here as I found working out what was going on by trial and error rather fun.

I did this using Linux Mint and LibreOffice but other OS and software should work.

Download the zip file of the font from fontlibrary or get it with the github repo above. Install it on your system. Right click on one of the font *.otf files Open with Fonts and click Install. (I’m using KnotsZoo-Rustic.otf for these examples)

Open LibreOffice Writer and select the KNOTS Zoo font and set the font size to say 40.

Start typing a random string of “i” an “o” characters. See if you can figure what’s going on.

After a while you should see that a string of four characters produces a glyph.

After some more experimenting you’ll find that each character in the string of four refers to one side of the glyph, starting at the top and going clockwise.

An “i” has a connection to the next glyph, an “o” has no connection on that side.

Now see if you can produce this pattern (hint: “oooo” is a blank glyph).

What about this one?

Now start adding “x” characters to the strings.

The full list of characters available is “hibox”. “h” gives heads, and “b” beaks or spirals.

For designing patterns LibreOffice Calc is good with four characters or one glyph per cell. its useful in the design stage as you can see the character string in the input line at the same time as you can see the glyph in the cell. You can also easily edit glyph by glyph.

The project’s github repository includes a python script to produce patterns with particular dimensions and symmetries. It outputs a sting of characters to the terminal that can be pasted back into your text editor or used on a webpage.

You can also use this font to play with other patterns such as the plane symmetry groups. Wallpaper group - Wikipedia) Or see my old blog entry

This one has p2 symmetry.

Now I could make a font for playing Escher’s Potato Game… Combinatorial enumeration of 2×2 ribbon patterns - ScienceDirect)

Play that game over here Escher Tiles - Interaction