gesturing paths → introduction
- Juancho Capic
- Eric Schrijver
- Élise Hallab
- Colm O’Neill
- Vincent Moisan
- Simon Egli
- S V
- Loraine Furter
- Samuel Rivers-Moore
- Anne Laforet
- Damien Safie
- Alexandre Leray
- Ludivine Loiseau
- Femke Snelting
Rediscovering fonts through their skeleton, the gesture of the body and their translation by digital tools.
The starting point for this worksession is the notion of skeleton, line, path and stroke. This approach of drawing interests us particularly because it returns without any doubt to the first ever trace of movement: the line left on the soft ground by the movement of a part of the body, and then of a tool. Are then immediately brought into play gesture, body, movement, distance, constraint, tool and then the trace and with it the possibility of reading.
As a technical construction, intellectual and cultural, software embodies specific conceptions of the objects they manipulate (here, stroke and shape). The PostScript programming language, commonly used in fonts, describe glyphs by their outline rather than by their skeleton, hence leading to a particular conception of the letter. The Metafont language rather describes the skeleton of the letter, trying to return to the gesture of the hand and the thickness of the nib.
Clone the project:
git clone email@example.com:relearn.gesturing-paths.git
- An introduction to the terminal, the history of bash, its integration in the core of the system.
- We could start with various tools (Inkscape, remote Plotter) to demonstrate what we mean by strokes. Bringing to the foreground gestures, paths, strokes.
- Different short exercises implemented as modules, to be able to have a little catalog of them, then to begin to pipe/glue them.
A list of potential exercises :
- Draw a small character (in metafont) which is passed on and altered.
- Coordinates — not so standard cartesian coordinates.
- Influence the point-matrix → it will also show something about the way points/shapes are described in digital files, how to understand the shape which has to be drawn.
- Swap point-matrices and pencil selections.
- Mix point-matrices, point-definitions, widths, starting-points, end points.
- Consider Hershey fonts in Inkscape somehow (it would be a shame to skip over such a nice library).
- Superness: the parameter that influences how tight or how loose the characters points liaison is.
- Pens: shapes, sizes, slants. And combine.
- Letter DNA/Paths: selecting similar glyphs and metafonting them.
- Pens 2.0: variables in pen shapes and slants. Knuth calls it the Calligraphy effect.
- Modulation: a DIN-esque approach to designing a Metafont? Building blocks, to then be combined into letters?
- Plotter sport training
Pre-intro notesNotes for the intro for Gijs, Pierre & Colm
Nice to be after “Can it Scale to the Universe?” because we could be an example of how to scale toghether.
Proposing small blocks, then modules, then piping these toghether, to build bigger blocks that would end up being characters, then again the building blocks for an alphabet.
Shapes and their awareness. The example of the letter A: three lines, bound together through their bones.
Then bringing this idea to look at a text, in a bigger typographic sense.
Decision to go on a Q&A model, lead by Gijs. Involving all and displaying the mindset for the workshop/worksession.
- Metafont, programme written by Donald Knuth, a coding genius, to design typefaces.
- Metafont is not about drawing the skin (or the envelope) but about drawing the skeleton of the letters and then adding some global weight, serif, italic, etc. parameters.
- The skin can change in an easier way infinitely.
- The skeleton is like the gesture you would produce with a pen, once you have the skeleton, you can dress it as you want.
- Gijs has been exploring pen plotters for 2 years.
- Is it only about drawing letters?
- Metafont is another way to look at typography, cf. “Lessons learned from Metafont” in LGRU reader Considering your tools.
- “Awareness” is a word which comes often: objects which are aware of themselves → interrogability. Complete awareness of a text.
- DIN-based font has used this system without being aware of Metafont.
- Classical font uses basic shapes that has been put together (in addition or subtraction).
- How we can mimic the way that we write?
- Metafont is a way to start treating letters as programs. =-)
- The relationship between letters is very obscure (kerning/letterspacing).
- How each letter is aware of itself when it is next to another.
- Of course it can be about other types of objects. We can escape from typographic work. Drawing symbols, not letters.
- Making the “most beautiful” curve according to Donald Knuth in the summer of 1979.
- Combining shapes to draw patterns. Type is some kind of pattern.
- Searching for beautiful answers (reversing a direction of a curve forces the program to find the smoothest way to continue the “original” path)
- You won’t/will learn Metafont in the workshop: not the inscribed goal of the workshop
- We want to experiment around Metafont to understand (a little bit) how it works
- AND IT’S GREAT!
Simon Egli : previous work with Metafont
Working as groups within the workshop, instead of individual works.
Sébastien’s project: working on a model of cartographic drawings, a metafont without the Metafont program.
Raster images with Metafont!!! → http://www.tug.org/TUGboat/tb08-2/tb18knut.pdf
[Executes two actions with two softwares one after the other, only if the first works; thr first one transforms the file into postscript (the extension is not in the name of the file but it is a poscript), the second one will open the latter]
mpost drawG.mp && evince drawG.1[Opens the file drawG.mp in a text editor in the terminal]
nano drawG.mp[It opens a text-editor in the terminal, you can edit]
[At the bottom of the file are a series of commands (ex: ^G Get Help)]
[To quit] ^X
[It asks if you would like to save?]
[Yes: save and quit] Y
[Where you want to save it, under which name]
To push the modified files back to the Git, see [[cheat-sheet::git]].
From MetaPost to MetafontFYI the files reffered to are located in the “Gesture” folder at the base of the “relearn.gesturing-paths.git”.
How do we integrate and pipe our glyphs into a font format to use in TeX or even Open Type Font?
We’ve been drawing our glyphs using MetaPost to enable EPS outputs to see our results.
To translate the .mp files into .mf files, the syntax is basically the same.
The basic idea is that you package all of your glyphs inside a file named fontname.mf.
The specificities of a font (glyph size, brush options…) can be determined in this file, or they can be determined one by one inside each glyph file.
All the glyph specifics are specified inside their own .mf file, so the structure:
Draw glyphs (you could use metapost to check your glyphs) and save as a.mf b.mf A.mf B.mf.
Specify sizes inside fontname.mf and include all of your glyphs using “input”
This now can be used inside TeX and all of it’s brothers and sisters.
Also, note that the mf2pt1 package can be used to convert Metafont files to Postscript Type1 fonts.
You’ll need to meet the requirements and install the package located here: http://www.ctan.org/tex-archive/support/mf2pt1
The mf2pt1.pl script will need to be modified as follows:
In the section “# Create a FontForge script file”.
- Generate($1:r + ".otf");
- Generate($1:r + ".ttf");
Then running this command will output your font file otf/ttf:
- perl mf2pt1.pl gesture.mf
Sometimes when you’re overwritting the same .mf file and export it as a font over and over, it doesn’t seems to change, so it’s better to delete the .tfm file after you create a new version.
It can be done by:
rm file.tfmOr directly in the same command line while you’re creating the font files:
rm file.tfm && perl mf2pt.pl metafontfile.mf
To generate the .eps files of the font that you’re creating in Metafont file:
mpost "&mfplain \mode=localfont; mag=100.375; input file.mf"
So much to say
A first time in Python. Thank you Eleanor for your patience.
With bits and pieces of other codes, this script manages to get the amount of characters from web pages and translate it to a visual graphic. For instance from the three main workshops of this week:
- Off Grid (2 pages)
- Gesturing Path (1 page)
- Can it Scale to the Universe (2 pages)
Once the figures are added for each workshop they are scaled down to allow these figures to become coordinates.
These coordinates, spread horizontally one next to the other, are transformed by MetaPost (mpost) and generates an image.
The next step that I didn’t work out was to change automatically the name file, using the date, so that this script could be run every day, or every hour and generate a new image.
The Python script and first genarated images are in the Git repository of Gesturing Paths.