Current project(s) - the mathematical side of doodling

[downwardsfromzero]

Thank you for the input, Don Foolio.

Yes, the parallels with I Ching hexagrams has not escaped me! Of course, It particularly crossed my mind as I approached the 64th glyph as I was drawing them. Just as I have also noted the passing resemblance to Allyson Grey's glyph series, which has remained at the back of my mind throughout - but it is good to be reminded of the specific reference.

One of my plans is to produce a chart, similar to the I Ching one, that organises the glyphs in a manner that highlights their relationships through stepwise changes - but I do acknowledge that it may require more than the two dimensions of a sheet of paper.

 

[downwardsfromzero]

Yeah, Allyson Grey totally beat me to it :lol:

Secret writing | Allyson Grey

www.allysongrey.com

 

[RhythmSpring]

Yeah, I was also thinking Allyson Grey, too. Her glyphs seem alive, like they're dancing as my eyes move from one to the next. They also seem vaguely Hebrew.

Soon we will be able to communicate with aliens!

 

[Hyper Turtle]

I've been tweaking things a bit, removed all the rule based stuff and added some import/export stuff, working on an interactive mode now - i'm gonna post some code within a week or two that will be fun to play with, for non-coders as well. It'll already include the results of all the spaces up to at least 7x6, and be able to pause and resume the brute forcing of larger spaces.

I'm thinking about outputting image files as well. Like some sort of black and white image that can then be used as a starting point in a graphics software maybe? Or if .xcf files containing paths rather than pixel data are the way to go, i'd have to look into that but suspect it's easy. If not, i can just make SVG and that can be imported as a path. Would you have use for such functionality?

It brute forces the 6x6 space in ca. 15min now on my laptop. It takes less than a million wrong turns to do it. Increasing the size of the space just a little bit has massive impact on the time though:

Runtime: 5:17:24
Wrong turns: 15262173

7x6: 5320 glyphs, 1361 archetypes with 62 that have symmetries, 3959 transformed versions

 

[downwardsfromzero]

Yeah, I was also thinking Allyson Grey, too. Her glyphs seem alive, like they're dancing as my eyes move from one to the next. They also seem vaguely Hebrew.

Soon we will be able to communicate with aliens!

Indeed. Some of her glyphs are the exact same ones that I've come up with, and the same approach to colour schemes too. (There's nothing new under the sun!)

I've played around with some styles of sketching the glyphs which can make them seem quite like Hebrew characters or Arabic script. There'll be some pictures of these in due course.

I've been tweaking things a bit, removed all the rule based stuff and added some import/export stuff, working on an interactive mode now - i'm gonna post some code within a week or two that will be fun to play with, for non-coders as well. It'll already include the results of all the spaces up to at least 7x6, and be able to pause and resume the brute forcing of larger spaces.

I'm thinking about outputting image files as well. Like some sort of black and white image that can then be used as a starting point in a graphics software maybe? Or if .xcf files containing paths rather than pixel data are the way to go, i'd have to look into that but suspect it's easy. If not, i can just make SVG and that can be imported as a path. Would you have use for such functionality?

It brute forces the 6x6 space in ca. 15min now on my laptop. It takes less than a million wrong turns to do it. Increasing the size of the space just a little bit has massive impact on the time though:

Runtime: 5:17:24
Wrong turns: 15262173

7x6: 5320 glyphs, 1361 archetypes with 62 that have symmetries, 3959 transformed versions

I have been attempting, on the most basic of levels, to get to grips with script-based options in GIMP. I was looking at how I might automate the process of running through all the valid combinations of quarter-glyphs. Part of this will involve tweaking the systematic naming protocol to expedite forming only valid combinations.

You're welcome to both the svg and the xcf data if you want to have a play with it. At the moment it's for a red/blue eye-wrecking colour scheme but I can convert to monochrome to spare your neurons. Any useful tips for how to implement script-based glyph generation as outline above would be gratefully received in exchange.

Also, I've got as far as downloading the GIMP animation plugin, but will be looking for reviews and opinions before going too far into that one...


The thought of working, with pencil and paper alone, through the possibilities for the 8×8 glyph space has given me enough of a headache for me to consider it worthwhile specifically learning some coding in order to achieve my procedural artistic goals! It's possible, HT, that I may call on you for rendering support as my old laptop might baulk at some of the more advanced stages of this project as so far envisioned.

Thanking all of you once more for your input and support!

 

[downwardsfromzero]

This clearly belongs here:
[youtube]

Allyson Grey clearly states that she sticks to squares and rectangles, so I'll take that lead to worry a little less about my own rectilinear tendencies

 

[RhythmSpring]

This clearly belongs here:
[youtube]

Allyson Grey clearly states that she sticks to squares and rectangles, so I'll take that lead to worry a little less about my own rectilinear tendencies

No excuses!

 

[downwardsfromzero]

:lol:
I love runes (and can actually read them a bit - but my understanding of Old Norse is rudimentary at best) being of Scandinavian descent. Sadly, they don't really fit into the mathematical remit of this particular project.

 

[Hyper Turtle]

Here's a cookie

I'm not done with making the python code usable, but i rendered the worlds i already have to SVG and made a little HTML page to view them. It works in Firefox and Chromium, and hopefully other browsers as well.

Unpacked size is about 16MB.

 

[downwardsfromzero]

Thank you so much! As we would say, "By golly, old bean - you've really pushed the boat out on this one!"
How did you automate the rendering of each glyph?

My planned updates to this thread have been somewhat delayed due to having visitors and then I and some other family members got a virus (not that virus!) which has also disrupted the flow of things. Soon I'll have scanned all my notes for ease of transcription and we'll see how it squares up (no pun intended) against your coding smoothness.

I still need to force myself to learn how to produce animated glyph sequences based on my library of quarter glyphs. I'm starting to envisage it along the lines of a spectrum analysis graphic like those that come alongside audio players. It's only mildly annoying that there are 33 archetypal quarter glyphs

 

[Hyper Turtle]

You're welcome! Glad you like it

Well, since i already had code that models the glyphs, it was just a matter of following the connections and do a little arithmetic to calculate the points for the different paths (one for the outer walls, one for the inner walls, one for the loop).

Below is the svg rendering function of the Glyph class - the whole class is too long to post here, it'll be there when i post the full code.

To understand this, all you need to know (apart from a little python) is that Glyph has a dictionary .squares that allows accessing the individual Square objects by the Vector(x,y) that represents their position in the grid. Square objects have ._in and ._out attributes that each hold one letter from 'rdlu', a .pos attribute that is the aforementioned Vector, and a function .next() that returns the next Square in the loop path. The move variable gets one letter from 'Lfr'. The unit variable is the side length of a square in pixels.

SVG is a text format similar to HTML, so it was easy to generate. I used three <path> elements and generated the point list ( d="..." ) for each. "M x y" means move to (x,y) without drawing a line, "L x0 y0 x1 y1 ..." means draw straight lines to a sequence of x,y pixel coordinates. "Z" closes the path.

So i could just load each of the already brute forced worlds, and write the output of each Glyph.svg() into separate files.

class Glyph:
    # ...
    def svg(self, **kwargs):
        unit = kwargs.get('unit') or SVG_OPTIONS['unit']
        outer_color = kwargs.get('outer_color') or SVG_OPTIONS['outer_color']
        inner_color = kwargs.get('inner_color') or SVG_OPTIONS['inner_color']
        outer_thick = kwargs.get('outer_thick') or SVG_OPTIONS['outer_thick']
        inner_thick = kwargs.get('inner_thick') or SVG_OPTIONS['inner_thick']
        path_color = kwargs.get('path_color') or SVG_OPTIONS['path_color']
        path_thick = kwargs.get('path_thick') or SVG_OPTIONS['path_thick']
        half = unit//2
        outer_lines = 'M 0 0 L '
        inner_lines = 'M {} {} L '.format(unit, unit)
        path = 'M {} {} '.format(half, half)
        path += 'L {} {} '.format(unit+half, half)
        square = self.squares[Vector(1,0)]
        while square.pos != Vector(0,0):
            x = square.pos.x * unit
            y = square.pos.y * unit
            path += '{} {} '.format(x+half, y+half)
            move = MOVES[square._in + square._out]
            # inner walls:
            if move != 'r':
                start_x = x + (0 if square._out in 'rd' else unit)
                start_y = y + (0 if square._out in 'ld' else unit)
                end_x = start_x + (0 if square._out in 'ud' else (unit if square._out=='r' else -unit))
                end_y = start_y + (0 if square._out in 'lr' else (unit if square._out=='d' else -unit))
                if move == 'L':
                    inner_lines += '{} {} '.format(start_x, start_y)
                inner_lines += '{} {} '.format(end_x, end_y)
            # outer walls:
            if move != 'L':
                start_x = x + (0 if square._out in 'ru' else unit)
                start_y = y + (0 if square._out in 'rd'else unit)
                end_x = start_x + (0 if square._out in 'ud' else (unit if square._out=='r' else -unit))
                end_y = start_y + (0 if square._out in 'lr' else (unit if square._out=='d' else -unit))
                if move == 'r':
                    outer_lines += '{} {} '.format(start_x, start_y)
                outer_lines += '{} {} '.format(end_x, end_y)
            square = square.next()
        path += 'Z'
        outer_lines += 'Z'
        inner_lines += 'Z'
        svg = '''
<svg id="svg" version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ev="http://www.w3.org/2001/xml-events" width="{}" height="{}">
    <defs>
        <linearGradient id="linear1" x1="0%" y1="0%" x2="100%" y2="100%">
            <stop offset="0%" stop-color="#05a"/>
            <stop offset="100%" stop-color="#0a5"/>
        </linearGradient>
    </defs>
    <style>
#outer {{
    stroke: {};
    stroke-width: {};
    fill: transparent;
}}
#inner {{
    stroke: {};
    stroke-width: {};
    fill: transparent;
}}
#path {{
    stroke: {};
    stroke-width: {};
    fill: transparent;
}}
    </style>
    <g id="glyph" transform="translate({},{})">
        <path id="path" d="{}" />
        <path id="outer" d="{}" />
        <path id="inner" d="{}" />
    </g>
</svg>'''.format((self.size.x+1)*unit, (self.size.y+1)*unit, outer_color, outer_thick, inner_color, inner_thick, path_color, path_thick, unit/2, unit/2, path, outer_lines, inner_lines)
        return svg

 

[downwardsfromzero]

Did you just hear that loud "WHOOOOSH!"?

I clearly have some way to go with my coding :lol:

[Edit: your explanation does make sense to me now that I actually read it. Essentially, the pre-existing libraries allow the svg generator to plot the relevant lines in the relevant places. This is starting to feel like we're closing in on the main artistic goal too - very cool!]

 

[Hyper Turtle]

I guess the last two decades of spending unhealthy amounts of time in front of screens did pay off in some ways

Yeah in theory, i could now generate any visual rendering desired. I just have to understand how it's supposed to look / work, then i can probably find a way to code that.

So far, everything was outside GIMP, and i've never really done any scripting in GIMP, so if/when that's necessary, i'll have to read up. I've been wanting to do that for a long time though, so it's a welcome opportunity. The good news is that GIMP allows scripting with Python, so i think the code i already have should be usable in there with no modifications (for loading the pre-calculated glyphs), and all that's left to do is write rendering logic that makes GIMP do exactly what we want.

---

For anyone who would prefer to view the glyphs online rather than download the zip, i put it on https://nexiantoys.freecluster.eu/glyphs/. It's a free web hosting service and i still haven't figured out how to make it support https, so you'll get a security warning. But it works exactly the same as the offline version if you dare to 'proceed anyway' - it just loads each svg image from the server rather than from your disk.

EDIT: it has (and enforces) https now, no warnings anymore.

 

[Hyper Turtle]

I'll try to give an english explanation what the svg rendering code does exactly:

- first, it stores some rendering parameters in local variables. I made it so they can be passed into the function by keyword arguments, or use default values otherwise. These are colors and thicknesses of the different parts of the image. For the renderings i did, i used the default values - a dark red color for the outer walls, an orangey color for the inner walls, and a blue-ish diagonal linear gradient for the loop path. The thicknesses are 5 pixels for the walls and 10 pixels for the loop.
- unit, ie. the side length of each square, is 30 pixels. half is 15 pixels. All of these default values are in SVG_OPTIONS which are omitted from the post.

- next, i start each of the SVG paths by moving to the appropriate starting pixel coordinates for top-left corner - 0,0 for the outer walls, 30,30 for the inner walls, and 15,15 for the loop.
- then i draw a line to the right for the loop, and initialise the temporary variable 'square' to the one at grid position x=1,y=0.

- i then repeat the following steps until i get back to the top left corner square, ie. grid position x=0,y=0:
-- calculate the current square's top-left corner pixel coordinates, store them in variables x and y.
-- draw a line to x+half, y+half for the loop. This is always correct.
-- for the inner walls, drag the line along if this square's move isn't "turn right". For this, it's sufficient to add the end coordinates for that line segment (unless the move was "turn left", then i need to add the start coordinates first, or i'll end up cutting a corner, ie. draw a diagonal line). Depending which way the connection to next square goes, wall segments need to be at the top, bottom, left or right edge of the current square. That's why the calculations have these if .. else components.
-- for the outer walls, drag the line along if the move isn't "turn left". Again the segment end coordinates are sufficient, except for right turns this time.
-- get the next square the loop goes through.

- finally i close all 3 paths, insert the rendering parameters and the constructed paths into an SVG template, and return the completed SVG as string.

 

[downwardsfromzero]

Thanks for the explanation. You are awesome and my wife thinks so too :lol: She was very impressed with what you've come up with when I showed her the locally-based version.

My main initial thought was to add a play button which allows the glyphs to be viewed like a slide show. The next obvious functionalities to add in that direction are a speed control and a randomisation/shuffle option - both within any given set and between different ones. I can envisage that controlling the colours of the various glyph components can be automated in a fairly straightforward fashion as well.

Learning Python scripting is edging its way nearer to the top of my to-do list. At least I have no excuse for getting bored... The goal of scripting animations withing GIMP seems well within grasp (assuming that part of GIMP is in a functional state :lol: )

EDIT: it has (and enforces) https now, no warnings anymore.

Does this now mean that the link can be edited accordingly, without breaking anything?

 

[Hyper Turtle]

Thanks for the explanation. You are awesome and my wife thinks so too :lol: She was very impressed with what you've come up with when I showed her the locally-based version.

My main initial thought was to add a play button which allows the glyphs to be viewed like a slide show. The next obvious functionalities to add in that direction are a speed control and a randomisation/shuffle option - both within any given set and between different ones. I can envisage that controlling the colours of the various glyph components can be automated in a fairly straightforward fashion as well.

Learning Python scripting is edging its way nearer to the top of my to-do list. At least I have no excuse for getting bored... The goal of scripting animations withing GIMP seems well within grasp (assuming that part of GIMP is in a functional state :lol: )

EDIT: it has (and enforces) https now, no warnings anymore.

Does this now mean that the link can be edited accordingly, without breaking anything?

Ah yes. I adjusted the link. Thanks

I had that thought too! A fun fact about SVG is that it is a true web format, meaning that it can be styled with CSS and scripted with JavaScript! I actually did use CSS to apply the colors and line thicknesses, but have obviously not animated them (yet). It would definitely be possible to create a single SVG file that does all of it. It could even have the controls, too. I suspect that a scripted SVG only really works in a browser though, but not in most image viewers.

I'm not familiar with the GIMP animation possibilities, the only thing in that direction that i've already done was making animated gifs, simply by having the individual frames on separate layers and checking the animation mark during export as gif. I don't remember if they're played top to bottom or the reverse. Creating those layers via python is certainly feasible, if there are no better options.

Btw, SVG files can not only be imported into GIMP as regular layers (thereby probably being converted from vector to pixel graphics), they can also be used as paths, or as alpha masks (controlling opacity of other layers), etc...

Are there any programming languages you're already familiar with? I speak a few, so maybe we find one we share.

When we're talking about animation ... have you heard of milkdrop? The visualisation plugin of good old winamp? The one that already made mindblowing graphics back when everything else only had bland kaleidoscope effects Man, so many possibilities. With this one, you can make the animation react to sound O_O

I've had 8x8 brute force running for some days, found 2028 glyphs so far, all archetypal. The most recent one:

 

[Hyper Turtle]

Oh haha i just found the gif i made with GIMP (from a Conway's game of life sequence)

 

[downwardsfromzero]

Holy heck you are a busy bee. It's great to have been able to supply some inspiration for you.

Sadly, my coding skills largely stopped somewhere around BBC basic :lol: although I did do a brief stint at FreeCodeCamp several years ago only to see all my efforts there disappear due to breaking my operating system and losing a whole load of logins in the encrypted cookies (and worse). This means I may have some rudiments of CSS in a dusty back closet of my mind somewhere; I mostly recall the sequence of introductory exercises being crushingly simplistic and perhaps that explains my lack of motivation in picking it back up again.

Yes, I have heard of milkdrop - I've possibly seen it on a friend's computer (Gary the ketamine monster) but I only got my own computer in about 2007, if you can believe it! It was some secondhand lump running something like Ubuntu not-very-much maybe. Back when I earned something approaching real money, I spent most of it on physical music media. I used to find computers intimidating until I started learning about Linux and FOSS.

So, we'll just have to see what I'll end up being able to contribute to actual coding this year.

With some of these new glyphs I get a little concerned that we may accidentally spell something gravely offensive in Arabic or Urdu or something (we probably already have :S )

Have you skipped straight to the 8×8 glyphs? It just seems worth adding in the 8×7 glyphs for reasons of both aesthetic and mathematical completeness. I was kind of dreaming that these ever-increasing set sizes might get dealt with some kind of magical glyph generation algorithm that somehow side-steps some of the effort of brute-forcing things, but maybe that just illustrates how slender my grasp on reality can be :lol: or on mathematics, for that matter...

 

[Hyper Turtle]

It's great to have inspiration to code something fun again. It's one of my favorite hobbies, but inspiration had been thoroughly lacking for a while now. Thank you!

BBC Basic, nice :=) I have fond memories of my basic programmable calculator that had 2x16 text display in school. A friend of mine was sick, he found out how to program his own character set, which enabled him to write a 2-player stick figure sword fighting game on that thing!

Well, it's not a problem for me if i end up doing all the coding. As long as my motivation wave keeps rolling, i'm happy. I just can't guarantee that it won't run out at some point, it's happened many times before.

Yeah i skipped 8x6 and 8x7. Basically i just wanted to see how bad it is for 8x8. It's so bad, i doubt it would finish this year even if i kept it running constantly. Maybe i'll brute force 8x6, i expect that one to finish within about a week of runtime.

For anything beyond that, i will have to either make the brute forcing significantly smarter, or actually find the set of rules that make my original approach work, for arbitrary grid sizes. Which i still hope to do, but am somewhat afraid of spending a lot of time on without getting anwhere. It was easier and quicker success to implement the svg rendering first

 

[Hyper Turtle]

Did some searching, i found the GAP (GIMP animation package). It seems to be unmaintained for a while, but following this post i was able to install it, the menus show up, looking good. Idk yet if everything works, according to the article it's not very likely. If not, i'll just use an older GIMP version and it should be alright.

Gonna have to see what it's about, if it does what we need it to do and if it's also scriptable.

Oh and i'm currently brute forcing 8x6, it's going faster than expected. Been running for 2 days and i'm pretty sure it'll finish today or tomorrow. It found 16750 glyphs so far, the most recently found is attached.