The Unfinished Project

This 3D printer is fun. It’s loads of fun. It’s a great machine, which can produce whatever you can think off. Or, whatever other people think off. I used to only have black plastic. And some red. So I printed quite a bit of black objects.

But now, I have 15 different colors of plastic now! And some of these colors are really awesome. Taking photos of prints is always hard, as the plastics are shiny. But I tried anyhow.

Want a unicorn? How about a pink one? From: http://www.thingiverse.com/thing:9084 sadly, it’s no longer a unicorn. Because it’s horn broke off. But on the good side. It has made a friend happy. (He has a crush on pink ponies)

Or how about a red dragon, protecting your heart. On a black base. Very nice print, but a bit of black got into the heart, and the final part got a bit burned…

Red yoda he be. Bad photo, and might look not very high quality, but it’s a tiny print.

Or a cute little red companion cube (it won’t stab you, or, it hasn’t stabbed me so far)

Or what about this. A green dragon. On a blue base. With a chest, which looks white. But in reality is the most awesome color ever made. It’s “glow in the dark”.

A dark green top of a tank. I still need to print the other tank parts. And I have the same tank in black. Which kinda shows how my printing quality has improved: http://daid2.mine.nu/~daid/IMG_20111007_010722.small.jpeg

These are just some of the colors I have now. And I still have more colors to play with:

So expect more colored prints from me!

So, here we are again. This time to tell you something about the software involved in 3D printing. The idea behind 3D printers is quite simple: You get an idea, imagine the object that you want, and print it.

In practice however, there are quite a few steps. You cannot simply think up a object, plug in the printer to your head, and print it. (And if you could most men would print a constant stream of female bodies…) The process from idea to object contains 3 major steps.

Below I’ll start with explaining some of the options in the first step. Namely “Modeling”

Continue reading “3D Printing – The Software – Modeling”

So, here we are again. And I wanted to tell you about a piece of software I’ve been working on.

I’ve done some very technical stuff about Skeinforge a few posts back. And I’m working on a faster (better?) replacement. But let me take a step back. A step back all the way, and explain a few other things first. Lets begin at the beginning.

Personal 3D Printing – How it started.

Personal 3D printers. It sounds like magic, or sci-fi. However, it started somewhere in 2007. With a machine called the “RepRap Darwin”. It took 2 years to develop this 3D printer, which had as goal to print it’s own parts as much as possible. So a RepRap could build another RepRap. A simple plan, but a difficult execution. It took 2 years to develop this printer into a working state. But once they had it figured out, it started to move forward.

This “RepRap Darwin” was the first machine. It’s bulky, slow, and (in my opinion: ugly). But it worked, and from this design the future was made. A future with better RepRaps. And so they developed the next generation of RepRaps.

Which all became better, faster, more accurate. The next generation was called the “Mendel”, which was cheaper to build, smaller, and generally better. And for about $400 in parts next to the printed parts you could own your own 3D printer now.

Still, there are issues. You need to source those parts yourself, look for suppliers, and buy the parts you need. Suppliers are not easy to find, and for some of the rare parts they are all based in the US. And shipping costs from the US to Europe are pretty high. After you got all the parts, you still had to assemble and figure out a lot yourself. There are a lot of options to figure out.

Personal 3D Printing – For the common man

And where there is difficulty, there are people working on sollutions. So some of the people that worked on the RepRap formed a company called MakerBot Industries. MakerBot Industries designed and started to sell a kit called the Cupcake CNC and later the Thing-O-Matic. This machine could print 3D objects, just like the RepRap. But was build using lasercut wooden parts instead of printed parts, so it could not replicate itself.

However, as a kit form you had everything you need for your own printer. No longer you needed to find parts from all over the world. No longer you had to construct some of the trickiest parts. You could just buy a kit and have your own 3D printer assembled soon.

The kit is sold from the US, so you still pay high shipping costs. And it has a build area of only 10x10x10cm for a large machine of 30x30x40cm. So interesting, but it can be done better. And (not to praise the Dutch or anything, really!) some guy from the Netherlands did.

Bring in the Ultimaker. A personal 3D printer for about the same price of a Thing-O-Matic, but with a 20x20x20cm build area for a 30x30x30cm machine. That’s the same size machine, with 8x the build volume. It’s also the fastest machine out there right now.

But best of all: It’s sold from the Netherlands. Bye bye expensive shipping costs! It’s still an expensive machine, but a guy needs a hobby. So I ordered one. And waited… waited… waited a bit more. And finally got the kit, it took 5 weeks from order to shipping. Which is about what they promise on the webshop.

Personal 3D Printing – Really?

It took me, solo, 1 man job, 8 hours to assemble the kit. From unpacking to first print. And it worked! Seeing a machine you build move for the first time is a rush I can tell you. Seeing the machine produce something is even a bigger rush.

These where my first 2 prints. They are far from perfect, because I didn’t follow one of the instructions correctly, but they where prints!

I didn’t want to figure out what was wrong, it was 01:00 already at that point. So I went to bed.

Now, the world is not as pretty as it always looks. I’ve had my share of problems from this point on. Both software and hardware related, being an Engineer by hearth this wasn’t a real issue for me. But it might cause a lot of frustration with other people.

So, really? Yes. Really, personal 3D printing is here. But not yet for the masses I think. I still get failed prints. But it’s really fun to do. Designing something and printing it in your own living room is a small wonder. I was talking to a friend of mine, who was visiting. And he said “So you could print the cube from Hellraiser?”, only a hour later we had 1 half of the cube in our hands. That’s the magic. Idea -> Design -> Print in a very short cycle.

So, and that was the beginning of 3D printing for me. Next, I’ll explain a bit more about the whole design and print process. In which I will show some software which is currently used. But that’s it for now. Goodnight.

A bit of back information. I have a 3D printer. Yes, I have one. I got myself an Ultimaker: http://blog.ultimaker.com/
Which is a cool machine. And I’ll do a write up one day. But for now, I’m tackling 1 piece of software.

Skeinforge.

Skeinforge is the tool which turns a 3D model into GCode, which are instructions for your 3D printer or CNC mill. And it has 2 major problems, one it’s slow, and secondly it’s DOG SLOW. Turning the gears1.stl from http://www.thingiverse.com/thing:10483 into GCode takes 6:52 minutes on a Core 2 2.33GHz machine. And it’s not the most complex model out there. People have reported convert times of 11 hours!

So, it needs to be faster. And it can be. First, install Psyco: http://psyco.sourceforge.net/ just do it. Skeinforge uses it, and it speeds it up. A LOT, time went down to 1:47. Pysco compiles python code with some JIT compiler. I don’t know the details, but it works. And it’s faster, so that’s good.

Now, bring in the profiler:

python -m cProfile –sort time skeinforge_application/skeinforge.py gear1.stl

Runs python with the profile, sorting on total time spend in a function.

I also noticed, Psyco messes with the profiler. With Pysco the profiler reports all time has been spend in the writeExport function. To which only a single call was made. I think pysco takes over from there and the profiler loses track of it. So profiling runs are done without pysco installed.

If we do this we spot 2 offenders. There are 50898067 of calls made “getStepKey”. And what does this function do… it returns it 2 parameters. As every call takes time, this is just a waste. The only place this function is used is in the same file. Removing all the calls to “getStepKey” and just replacing them with the result saves almost a minute! Bringing the export without Pysco down to 5:58 minutes. That’s a 15% improvement with just a minor code tweak!

Next up, “addPixelToPixelTableWithSteepness”, this function is called 34524828 times, and it spends 34 seconds in it. And calls “addPixelToPixelTable” with (x,y) or (y, x) depending on it’s parameter “isSteep”. Now, this all looks an awful lot like parts of the Bresenham’s_line_algorithm which is good, as that’s a fast line algorithm, but it’s bad to split it into functions! The addPixelToPixelTable is only called from addPixelToPixelTableWithSteepness. So that’s 2 calls overhead for every “pixel”. Also, the “isSteep” is checked for every pixel, while it’s static during the whole line draw. So the test for isSteep can be moved before the looping and just make 2 special cases.

And with those adjustments we are down to 4:54 minutes. That’s a 30% improvement. Now let’s see what psyco does with it. With the code changes and psyco installed we run in 1:36 minute. Which is a 11% improvement. Not as good as without psyco. But maybe with more complex models the time saved will improve.

I did the following patch on the code, which should apply on any version of Skeinforge: A pre-patched file can be find here (from SF35, other SF engines might not work with this file!)

--- skeinforge-35/fabmetheus_utilities/euclidean.py    2011-09-27 10:39:35.000000000 +0200
+++ skeinforge-35-org/fabmetheus_utilities/euclidean.py    2011-09-26 17:34:36.000000000 +0200
@@ -63,7 +63,7 @@
 
 def addElementToPixelList( element, pixelDictionary, x, y ):
     'Add an element to the pixel list.'
-    stepKey = (x, y)
+    stepKey = getStepKey(x, y)
     addElementToListTable( element, stepKey, pixelDictionary )
 
 def addElementToPixelListFromPoint( element, pixelDictionary, point ):
@@ -115,7 +115,7 @@
 
 def addPixelToPixelTable( pixelDictionary, value, x, y ):
     'Add pixel to the pixel table.'
-    pixelDictionary[(x, y)] = value
+    pixelDictionary[getStepKey(x, y)] = value
 
 def addPixelToPixelTableWithSteepness( isSteep, pixelDictionary, value, x, y ):
     'Add pixels to the pixel table with steepness.'
@@ -173,20 +173,12 @@
     xBegin = int(round(beginComplex.real))
     xEnd = int(round(endComplex.real))
     yIntersection = beginComplex.imag - beginComplex.real * gradient
-    if isSteep:
-        pixelDictionary[( int( round( beginComplex.imag ) ), xBegin)] = None
-        pixelDictionary[( int( round( endComplex.imag ) ), xEnd )] = None
-        for x in xrange( xBegin + 1, xEnd ):
-            y = int( math.floor( yIntersection + x * gradient ) )
-            pixelDictionary[(y, x)] = None
-            pixelDictionary[(y + 1, x)] = None
-    else:
-        pixelDictionary[(xBegin, int( round( beginComplex.imag ) ) )] = None
-        pixelDictionary[(xEnd, int( round( endComplex.imag ) ) )] = None
-        for x in xrange( xBegin + 1, xEnd ):
-            y = int( math.floor( yIntersection + x * gradient ) )
-            pixelDictionary[(x, y)] = None
-            pixelDictionary[(x, y + 1)] = None
+    addPixelToPixelTableWithSteepness( isSteep, pixelDictionary, None, xBegin, int( round( beginComplex.imag ) ) )
+    addPixelToPixelTableWithSteepness( isSteep, pixelDictionary, None, xEnd, int( round( endComplex.imag ) ) )
+    for x in xrange( xBegin + 1, xEnd ):
+        y = int( math.floor( yIntersection + x * gradient ) )
+        addPixelToPixelTableWithSteepness( isSteep, pixelDictionary, None, x, y )
+        addPixelToPixelTableWithSteepness( isSteep, pixelDictionary, None, x, y + 1 )
 
 def addSquareTwoToPixelDictionary(pixelDictionary, point, value, width):
     'Add square with two pixels around the center to pixel dictionary.'
@@ -195,7 +187,7 @@
     y = int(round(point.imag))
     for xStep in xrange(x - 2, x + 3):
         for yStep in xrange(y - 2, y + 3):
-            pixelDictionary[(xStep, yStep)] = value
+            pixelDictionary[getStepKey(xStep, yStep)] = value
 
 def addSurroundingLoopBeginning( distanceFeedRate, loop, z ):
     'Add surrounding loop beginning to gcode output.'
@@ -253,20 +245,12 @@
     xBegin = int(round(beginComplex.real))
     xEnd = int(round(endComplex.real))
     yIntersection = beginComplex.imag - beginComplex.real * gradient
-    if isSteep:
-        pixelDictionary[(int( round( beginComplex.imag ) ), xBegin)] = value
-        pixelDictionary[(int( round( endComplex.imag ) ), xEnd)] = value
-        for x in xrange( xBegin + 1, xEnd ):
-            y = int( math.floor( yIntersection + x * gradient ) )
-            pixelDictionary[(y, x)] = value
-            pixelDictionary[(y + 1, x)] = value
-    else:
-        pixelDictionary[(xBegin, int( round( beginComplex.imag ) ))] = value
-        pixelDictionary[(xEnd, int( round( endComplex.imag ) ))] = value
-        for x in xrange( xBegin + 1, xEnd ):
-            y = int( math.floor( yIntersection + x * gradient ) )
-            pixelDictionary[(x, y)] = value
-            pixelDictionary[(x, y + 1)] = value
+    addPixelToPixelTableWithSteepness( isSteep, pixelDictionary, value, xBegin, int( round( beginComplex.imag ) ) )
+    addPixelToPixelTableWithSteepness( isSteep, pixelDictionary, value, xEnd, int( round( endComplex.imag ) ) )
+    for x in xrange( xBegin + 1, xEnd ):
+        y = int( math.floor( yIntersection + x * gradient ) )
+        addPixelToPixelTableWithSteepness( isSteep, pixelDictionary, value, x, y )
+        addPixelToPixelTableWithSteepness( isSteep, pixelDictionary, value, x, y + 1 )
 
 def addXIntersectionIndexesFromLoop( frontOverWidth, loop, solidIndex, xIntersectionIndexLists, width, yList ):
     'Add the x intersection indexes for a loop.'
@@ -459,7 +443,7 @@
         y = int( point.imag * oneOverOverlapDistance )
         if not getSquareIsOccupied( pixelDictionary, x, y ):
             away.append(point)
-            stepKey = (x, y)
+            stepKey = getStepKey(x, y)
             pixelDictionary[ stepKey ] = None
     return away
 
@@ -1499,7 +1483,7 @@
     squareValues = []
     for xStep in xrange(x - 1, x + 2):
         for yStep in xrange(y - 1, y + 2):
-            stepKey = (xStep, yStep)
+            stepKey = getStepKey(xStep, yStep)
             if stepKey in pixelDictionary:
                 return True
     return False
@@ -1515,7 +1499,7 @@
     squareValues = []
     for xStep in xrange(x - 1, x + 2):
         for yStep in xrange(y - 1, y + 2):
-            stepKey = (xStep, yStep)
+            stepKey = getStepKey(xStep, yStep)
             if stepKey in pixelDictionary:
                 squareValues += pixelDictionary[ stepKey ]
     return squareValues

EDIT

And there is even more, this is just to stupid… for every ‘plugin’ run it checks if other plugins already ran on the GCode. All fine and great, but it does so by splitting the code in lines, for each line replacing text, and then split the string and check it if it contains a certain tag. I replaced the whole function by 6 lines of code. Shaving 40 seconds of the 4:54.

--- skeinforge-35-org/fabmetheus_utilities/gcodec.py    2011-09-20 11:17:43.000000000 +0200
+++ skeinforge-35/fabmetheus_utilities/gcodec.py    2011-09-27 15:09:43.000000000 +0200
@@ -166,24 +166,10 @@
     'Determine if the procedure has been done on the gcode text.'
     if gcodeText == '':
         return False
-    lines = archive.getTextLines(gcodeText)
-    for line in lines:
-        withoutBracketsEqualTabQuotes = getWithoutBracketsEqualTab(line).replace('"', '').replace("'", '')
-        splitLine = getWithoutBracketsEqualTab( withoutBracketsEqualTabQuotes ).split()
-        firstWord = getFirstWord(splitLine)
-        if firstWord == 'procedureDone':
-            if splitLine[1].find(procedure) != -1:
-                return True
-        elif firstWord == 'extrusionStart':
-            return False
-        procedureIndex = line.find(procedure)
-        if procedureIndex != -1:
-            if 'procedureDone' in splitLine:
-                nextIndex = splitLine.index('procedureDone') + 1
-                if nextIndex < len(splitLine):
-                    nextWordSplit = splitLine[nextIndex].split(',')
-                    if procedure in nextWordSplit:
-                        return True
+    if 'procedureDone="'+procedure+'"' in procedure:
+        return True
+    if '(<procedureDone> '+procedure+' </procedureDone>)' in procedure:
+        return True
     return False