Loom Art in Tableau

Recently, I completed a project which entailed visualizing the digits of Pi in an artistic manner (see The Beauty of Pi). One of my main goals was to create a circular image with each value (0-9) grouped together, then each digit of Pi connected using a curve (a Bézier curve to be precise). Here’s an example of what I created (Note: this visualization is not included in the original post):

As you can see, I was able to get it working as desired, but this was my first time using Bézier curves and I struggled a bit with it. After fighting with the table calcs for a while, I reached out to Chris DeMartini, who is the expert in Bézier curves in Tableau. Chris, recognizing what I was trying to do, sent me the following visualization on which had done something similar.

When I saw this and realized what it was doing, I was completely amazed as the loom image was made completely of Bézier curves. This was some truly fascinating stuff. But I returned to the task at hand and used the viz to help me correct my table calculations. It was just the push I needed and, as you can see above, I was able to correct my problems.

But, after I had finished the project, I kept thinking about the loom image Chris had created and I started to wonder if it were possible to convert any image to such a pattern and visualize it in Tableau. So, I began doing some research, starting with the links on Chris’s visualization.

A circular loom is a round apparatus used for weaving yarn or thread. It typically has 200 pins which are used for stringing the thread. In 2016, an artist named Petros Vrellis created an algorithm which takes a digital image, analyzes the dark and light spots, then outputs a knitting pattern, allowing him to re-create that image on the loom using a single length of thread. The video below shows the process in action.

Incredible, isn’t it!

The Algorithm

For the Tyrion Lannister image, Chris got his data and rendering algorithm from an html canvas version available here: Tyrion Lannister Image. But, as I said earlier, I wanted to be able to take any image and create loom art. Mr. Vrellis had committed to open-sourcing his code, but I was unable to find it. I did, however, find a number of algorithms on Github that did basically the same thing. I chose one, created in Java by the user, shlonkin, which seemed to give me what I needed. One problem with the code was that it didn’t actually output the details of each line it created—it placed everything into arrays and created an on-screen image, but didn’t actually output the data. After taking the code apart, I was able to add a handful of lines to output a csv file (At the end of this post, I’ll direct you to my modified version of the code, as well as provide instructions on how to use it to create your own loom art). I should note that I am not a Java programmer, but I have a programming background and can make sense out of just about any language you put in front of me. But writing code in that language can often be an entirely different story. So, if you are a Java programmer, it’s likely my code is not up to snuff, but it works!

From here, I started uploading image after image to see how they looked. It’s important to note that the algorithm does not do a great job with every image. For instance, I attempted to generate the loom pattern for a number of artworks from Escher, Picasso, and Salvador Dali, but none of them were even remotely recognizable. It’s difficult to predict which images it will do well with and which it won’t, but my theory is that there needs to be a fairly clear distinction between the foreground and background or else everything will just sort of blur together. That being said, I had a lot of fun uploading various images and seeing the results.

Visualizing in Tableau

Now that I had the data in a CSV file, I was able to put it into Tableau and start to visualize it. This was very easy as it was just a matter of drawing lines using the paths generated by the code (this is included in the how-to section, in case you haven’t done it before). The first image I plotted was Afghan Girl, a famous portrait by Steve McCurry which appeared on the June 1985 cover of National Geographic. Here’s the original:

And here’s an animation of the loom version being “drawn” line-by-line:

In the end, I created a visualization that includes 10 different photos and paintings, most of which I expect you’ll recognize. I also included a version of Chris’s original Tyrion Lannister photo. In addition to allowing you to change the color of the thread, the visualization also allows you to show anywhere from 1 to 4,500 lines. For instance, here’s are a series of images showing 1,000, 2,000, 3,000, and 4,500 lines. Note: You can click on each image to see the interactive version.

1,000 Lines

2,000 Lines

3,000 Lines

4,500 Lines

I should point out that Chris used Bézier curves with a slight bend, rather than straight lines. This has a small, yet noticeable impact on the overall quality of the images. However, I chose to just use straight lines as they are easier to create and I found that a slight increase in the number of threads helped to enhance the overall quality.

How-To

So, I don’t know if anyone will be interested in actually creating some of their own loom art in Tableau, but if you’re interested, here’s are the steps required:

1. Download and install the Processing IDE: https://processing.org/download/
2. Download the ImageLoom.pde file from my Github repository: https://github.com/flerlagekr/AutomatedArt
3. Open the ImageLoom.pde file in Processing.
4. Follow the instructions in the comment block at the top of the code (don’t worry—they’re simple).
5. The program will output a csv file. Connect to it with Tableau.
6. Move X to the Columns shelf and Y to the Rows shelf.
7. Move Path to the Detail card.
8. Change the chart type to Line.
9. Move Path  Order to the Path card, then change it to a Dimension.
10. Change the size of the lines to the smallest possible.
11. Change the color to black (or whatever thread color you prefer).
12. Change the color transparency to a low value (5-15% seems to work well).
13. Change the y-axis to Reversed.

The screenshot below shows the final result.

And that’s all there is to it. If you happen to create your own loom art, then I’d love to see it!

Update, 11/08/2017: As I noted above, the real workhorse in this process is the algorithm that chooses the paths of the lines to be written. I borrowed the code from the user, "shlonkin" on github (I'm trying to get more details about this person so I can give her/him proper attribution on this post), but others have written similar code. In fact, after posting this blog yesterday, Roberto Reif referred me to a brilliant post he wrote last November. If you are interested in the technical details of how these algorithms work, then I definitely recommend reading Drawing with Straight Lines.

Ken Flerlage, November 7, 2017

Twitter | LinkedIn | Tableau Public