Introductory splash screen and tools window with icons

When starting a new project the user is allowed to input the size of their Canvas to work on.

The size window

Once the user inputs the size, OSFA calculates the number of sprinkles and displays the Canvas. In the preferences window, the user can select whether they would like a grid to be displayed. Each square in the grid represents one sprinkle.

The user's canvas with a grid enabled

The preferences window

The user's canvas with the grid disabled

The user may then begin drawing their diagram. There are three different tiers that a user has to work with. If a sprinkle is designated as red then it will be the raised to the highest level when the image is converted to 3D, orange is the middle level, yellow the lowest. Therefore, the following 2D drawing:

will look like a rising and falling staircase in 3D, as can be seen here:

The above image converted to 3D

In the creation of their 2D image, the user has 3 different brush sizes available to them, 1×1, 2×2, and 3×3:

The user can also create 3D shapes: hemispheres, cones, and cylinders, as well as Braille labels. In order to create a 3D shape the user selects the shape’s tool and then drags their mouse across the sprinkles they would like to be included in the shape. The selected pixels will appear gray, like so:

In the process of creating a 3D shape

Upon release of the mouse, a 2D circle will appear that encompasses all of the sprinkles that were selected. The color of the circle denotes the 3D shape that will be created: hemispheres are green, cones are blue, cylinders are purple. Here is the 2D circle that was formed after the mouse was released in the above image:

The user can add as many 3D shapes as they would like:

Here is the 3D view of the three created shapes:

Also available are the eraser and clear all tools. They both do just as their name suggests. The eraser tool may also be used with any of the three brush sizes and, when dragged, rids of any tier colors that have been placed over the selected area. If the eraser tool is selected and then a 3D shape or Braille label is selected then that object is erased. The clear all tool clears the entire canvas.

Also, a user can open an image file. It will then be sprinklized and available for the user to edit with any of the features mentioned above.

Once a user is done they can use a tool bar option to send their image data to the Blender script which will render their 3D image for viewing as well as produce the STL file necessary for printing the object.

Linked List Node Print

The previous implementation of hemispheres came in very handy during this process. Braille letters consist of a 2 x 3 grid and the selection of spots in the grid that are filled with a hemisphere determines the letter it represents. Therefore, we only needed to figure out which locations would represent a spot on the grid and place a hemisphere at each of the necessary locations for each letter.

In the GUI, a user can select a sprinkle that they would like to represent the top left corner of the label and fill in the text box in the label dialog. Here is an image of a Braille label that we made and printed:

It is especially interesting to note the size of the hemispheres created. We needed to be sure that the hemispheres were big enough so that they could be distinguishable, yet small enough so that they don’t take up too much space. In the future, we plan to make the “font” size of the Braille lettering configurable.

Also, here is a picture of a linked list node that we recently designed in our GUI and printed:

The GUI implementation began when we needed a way for users to easily create hemispheres, and other 3D shapes, in their objects. Using the Canvas widget from the Tkinter Python module, and its ability to easily create rectangle objects in specific positions, we were able to represent the sprinklized 2D image as a collection of squares, one per sprinkle.

To select an sprinkle, we implemented a mouse listener to pay attention to mouse clicks and keep track of which square the mouse was over. We then used an attribute of the Canvas widget, object tags, to keep track of which squares had been selected. When the user clicks a sprinkle, we are able to find which square (rectangle object) it’s represented by and place a selected tag on it. Once the user is done, we can go back and get all the sprinkles that had been tagged to determine the location and size of the 3D shape. To allow for better visibility of where and how big the object will be, when a square is selected, it changes colors. There is also a deselect feature (enacted by clicking on an already selected sprinkle) which removes the selected tag and changes the color back to black.

In order to allow the user to easily select the image they wish to sprinklize, we have implemented a file picker, available through a “Choose your destiny” menu option.

After getting a basic GUI set up and having a way for users to easily select regions of their image, we thought it would be inice to allow for different textures in the 3D object. These may be especially useful in the future if, for instance, one would like to differentiate between colors in a diagram.

We attempted to do this by creating a “field” of tiny cones inside the selected area. This didn’t turn out as well as we had hoped as the cones were too small for the printer to produce. However, we will most likely come back to this feature in the future and see if we can tweak it for better results.

Thrilled with our success for all of half a day or so, we quickly came to the realization that because we were using sprinkles (which are square), even with a wide range of elevation options, making a smooth hemisphere with the Cupcake would be almost impossible. It’d be like trying to create a pyramid or a dome and getting a ziggurat instead.

Ziggurat!

So we began brainstorming ideas for creating half a sphere over the surface of our model in Blender, using only the Python scripts. This was problematic to say the least because a) most of Blender’s power comes from the manipulatable interface of the model itself, as well as the hotkeys. Both of which are useless when scripting; and b) There is no “create half sphere” handy hotkey period, even if we could use them. In a fit of creative delusion, frustrated hair-pulling and occasional trips to the local icecream shop, we came up with four ideas. (The last one worked, in case you were panicking on our behalf.)

Idea 1 went something like this: “If we create a whole sphere (Blender lets us do this pretty easily) and chop it in half, we’ll have half a sphere!”   Not only did we fail to find a reasonable way of removing half a sphere’s vertices, but we also realized that we’d have to fill in the bottom of what would essentially be an overturned bowl shape. That idea was crossed out. I’m sure it’s possible to do, but our fate lay along a different path etcetera etcetera.

Idea 2: “There’s this cool modifier called ‘Subsurf’! It makes things all rounded!” I’m not quite sure why this one was a flop. I think it had something to do with my tendency to form vague ideas around nifty buttons in art programs.

Idea 3: “We could create branching arcs above the x-y plane, and just fill in the shell with vertices.” See “Idea 2”.

Idea 4 (The One That Worked): “Wait! Boolean expressions! Yes!”

The gist of what we ended up doing is that we realized boolean operations on different objects are pretty simple to script. Boolean options in Blender work just as they do in logic. “And”, “or”, and “not”. We used the Difference boolean operation on a cube and a whole sphere, after positioning them so that they overlap about halfway. What this did was create a sort of ghost mesh of a half-sphere, by telling Blender “remove all of object A that intersects with object B”. (“Difference” is the only Boolean operation in Blender where it matters what order you specify the two objects). So we ended up with a hemisphere (like we wanted), because the rest of that sphere shape overlapped with the dummy cube- which we deleted afterwards.

Some domes

Now that we could create rounded surfaces wherever we wanted; the next step was to let the user specify where they wanted them, using a GUI.

We looked at some of the layer patterns skeinforge was creating and we found layers like this abound:

As you can see, there are many little squares visible inside the object and then skeinforge tried filling in around them. After getting slightly annoyed at skeinforge, we thought that maybe it wasn’t the program’s fault and considered what was being inputted into skeinforge to make it act in such a way.

Our creation of a 3D object is essentially placing many many cubes in a pattern corresponding to the original shape. Therefore, when there are multiple cubes placed together many faces were created that weren’t really necessary. They were actually obstructive to the process because when the object was sent to skeinforge, it tried to account for all the faces on all the cubes. The poor thing!

So we had to find some way so that only the outside faces, those that were necessary, were created. After much brain racking, white board diagrams, and thinking about each sprinkle’s role within the shape, we came up with a theory on how to fix our internal faces problem.

We decided that each sprinkle would need a top and a bottom face, as these faces will never be dublicated by another sprinkle. Then we had to look at the four sides of each sprinkle and decide where it should be allowed to have faces. We gave each sprinkle surrounding the current sprinkle, s, a number. Like so:

Then, in our Python program we had a four character string for s. If we looked at the sprinkle in the 1 position and saw that it wasn’t to be used in the final object, then we put a 1 as the first character in the string, indicating that, eventually, a face will need to be made facing that position. If the sprinkle at that position is not to be used, then a 0 would be put into the first character, indicating that a face should not be created there.

This method is done for all four positions for all sprinkles that were to be used in the object. Then we sent all the strings with their corresponding sprinkle coordinates into Blender.

Once in Blender we just have to look at the string of neighboring sprinkles to see where to make faces for each sprinkle. We then tested an object. In Blender we can see which faces have been created and it seems, with a few exceptions, that our method has worked.

After exporting the STL and running it through skeinforge, there is a noticable difference in the filling patterns that are created. Here is an example of a layer produced by skeinforge now:

The printer seems much happier while producing the objects as well. This is especially important, as loyalty is a key factor in the quest for world domination.

To script a 3D object you need to specify the coordinates of its vertices. In the case of a Sprinkle- which is essentially a cube- eight of them. But all we really need for that is the uppermost “origin” coordinate of each Sprinkle, and a Sprinkle’s length. Those three elements are what we exported from our Python program as a text file- and then imported into Blender. Once there we scripted the creation of each Sprinkle we were given, using an arbitrary value for the height of every one. Changing this “z value” is something we’ll come back to later when we start exploring different topographical heights in our images.

This all sounds pretty straight-forward, but right here is about the time we started running into problems- all of which came up as marvelously cryptic error messages when we ran this Blender output through Skeinforge. (Skeinforge is an open-source print-head mapping software that translates 3D models into something the Cupcake can use).

Our first problem had to do with a warped triangle-filled structure that we were getting instead of a clean, solid cube. If you specify four vertices they should make a face, right? I mean, a square face only has four vertices. Turns out if you don’t list the vertices in order (clockwise or counter-clockwise), the entire thing twists itself up and then the computer explodes. (not really).

So for future reference, a “hole in the triangle mesh”, despite the fact that there aren’t supposed to be triangles in your image anywhere ever, means something along the lines of “you fail at playing connect-the-dots.”

Here are some pictures from Blender:

We refer to him fondly as Stickzilla.

We have a long way to go toward a streamlined, elegant program, but the important thing is that we’re making great progress toward our first completely home-grown print job.  (Which means the beginning of scanned diagram prints, and that means using our doe-eyed little Cupcake printer to take over the world.  Aww, look at its cute opto-endstop wires spewing all over with happiness.)

Anyway, this is where the Sprinkle comes in.  Pixels are too small for a printer like the Cupcake to use- I mean, it’s possible, but it’d be sort of like using a fat marker to trace a line  and then an even thinner line, and expecting anyone to tell the difference.  At this point it’s much more efficient to work with the Cupcake instead of encouraging it to explode in gear-jittering frustration.

The Sprinkle is a construct that we came up with to simplify the breaking-up of pictures.  It’s like a pixel, but bigger.  In Python, we analyze a picture to determine which lines warrant printing, based on how much of a Sprinkle is “covered”.  It’s sort of like laying a transparent sheet of graph paper over a diagram and then checking which boxes are darkened past a certain threshold.  If a Sprinkle is chosen to become part of something so much bigger and more noble than itself, then its coordinates are stored and its contents subsequently blackened entirely, and mapped onto a second image.  The result is a somewhat blocky version that is a) simplified, and b) useful for the next step- adding a third dimension.

Both the Sprinkle size and the threshhold percentage (what decides whether or not a Sprinkle is going to be used) can be changed, giving us a little refinement in Sprinklation.  Here are some pictures.  I did not draw that stick figure and take no responsibility for its  face.

Original

Sprinkle size, 7 pixels. Threshold 70%

Reduced threshold to 30%

Increased Sprinkle size to 20 pixels.