Using the latest Banate CAD: williamaadams.wordpress.com/2011/12/19/banate-cad-lurches-towards-2011-finish-line/

I took a snapshot out of one of the blobby animations I was doing. I then pulled that .stl into OpenScad and created a little cup holder for my desk.

This thing is a convenient blobby cup holder. Put some sticky rubber feet pads on the bottom, and it will make a nice addition to your desk.

A couple of times now, I've seen discussions around the topic of creating tubular shapes that have one profile on one end, and another profile on the other end.

These things are a couple of examples of creating such things.

It's a work in progress, but it's a fairly straight forward process. I think this technique can be used to create things like frosting heads, or sugar cookie templates.

It's still a work in progress because when I generate the shape in Banate CAD, the face normals are turned the wrong way, so I use Mesh Lab to flip them after the .stl is generated.

If they could be mated to something with threads on it, you could imagine making hose attachments fairly easily. Also good for mating differently shaped things, like square tubes to round tubes.

Well, "Santa" might be a bit of a stretch, but it is that time of the year.

Since the latest version of Banate CAD has blob support:
williamaadams.wordpress.com/2011/12/05/banate-cad-third-release/

I can finally make nice blobular Christmas ornaments.

This thing is my attempt to make something vaguely humanoid. My daughter suggested I just go for a snowman, for pragmatic reasons (I'm no artist), but I went for some arms and legs anyway. I'm sure given enough typerwriters I could make it look really human in time.

I was hungry, so I thought I'd model up some peanuts.

This thing is actually formed out of metaballs.

It's just a blob, with a displacement map on the vertices, and the same texture as a color map on top of that.

The technique is similar to how the Earth Shot thing was created, but it uses the metaballs to calculate vertices.

The texture map file was downloaded from the internet, so it has a water mark. You can make a 2-nut peanut, or a 3-nut, or whatever. Just use more balls. Choosing a better texture/height map will make it look better.

I first tried to model metaballs in OpenScad. That effort was preliminary, indicating to me that it's not an easy egg to crack.

This thing cracks the proverbial metaball egg.

I have implemented a metaball routine in Banate CAD which gives you fairly decent results in relative real-time. That is, you can setup a fairly simple network of 'balls', and generate an isosurface for them in a matter of about a second, or a few seconds if you want to go for much higher resolution, or have a network with a ton of balls in it.

Metaballs/Blobs are used quite a lot in games for getting that nice blobbly affect on characters. It tends to make things look more organic than what you can typically achieve with more mechanical mechanisms.

This is great for modeling as you can quickly try out various configurations of balls to get all sorts of blobby effects. The "seat", or "face" model included here consists of just 4 influencing balls, so it's fairly simple.

In the picture, I've used fairly high resolution. The model is much lower resolution, but realistically, it would print about the same.

Also, in the picture, I'm showing the influencing balls, just for visualilzation. I turn them off to actually generate the .stl file.

I think the approach I'm taking is actually unique, as I haven't quite seen it done my particular way in the literature. Not a bad result for NOT using the GPU, and doing it purely in Lua.

You can play with the .fab, but it won't have the same results as I'm getting until this Sundays (12/4/2011) release of Banate CAD.

Since I made a new release of Banate CAD today:
williamaadams.wordpress.com/2011/11/28/banate-cad-second-release/

I thought I'd make somethingto to go with it. Well, while I was out in space taking pictures of the moon, and space ships, I thought, hay, why not turn the camera towards earth and take a couple of snaps, and create a model while I'm at it.

This thing is a vector normal mapped (a new term I found on the internet) model of the earth.

I grabbed a couple of high quality pictures from the internet, and just threw them into Banate CAD, the same way as I created the moon shot, and there you have it!

I'm sure someone is dying to tell me the earth is an oblate spheroid, and that I can't model it strictly as a sphere, but I think at these sizes it won't really matter.

Lithophanes and Height maps seem to be a popular subject these days. I found an interesting picture of Gandhi on a stamp.

This is a Lithophane of Gandhi on a stamp.

Any number of lithophane prints can be made by simply changing a file name in the .fab script.

Ever since I saw the Mobius Heart earlier this week:
thingiverse.com/thing:13861

I've been slaving away at the forge trying to replicate that feat in a solid math sort of way.

This thing represents a parametric torus, which is NOT the same thing as being able to create a heart shaped Mobius strip, but it is one step closer.

Basically, you can give the torus a function which determines the profile of the cross section of the torus as it sweeps around. In this case, I've used the SuperEllipse formula:
en.wikipedia.org/wiki/Superellipse

You could just as easily substitute a 2D superformula and make even more wild Torii.

The critical piece of code is right here:

local seprofiler = param_superellipse.new({
XRadius = 3,
ZRadius = 20,
N = 0.2,
})

local lshape = shape_torus.new({
HoleRadius = offset,
ProfileSampler = seprofiler,
USteps = 90,
WSteps = 180,
MinPhi = math.rad(0),
MaxPhi = math.rad(360), -- Great circle
MinTheta = 0,
MaxTheta = math.rad(360), -- profile
})
addshape(lshape)

Just change the values on that param_superellipse thing and you'll get different shapes. If 'N'=1, for example, you'll get more classic Ellipse/Circle behavior. 'N' 1, up to around 5, and you get the pointy thing going on.

While I was out exploring the moon using this model:
thingiverse.com/thing:14011

I came across a space ship, which you can see modeled here. There was some sort of inscription, which I interpret to mean:
"All Your Toroid Are Belong to Us!"

I took a scan of the inside, and as you can see, it's empty in there. Further proof that the aliens have long since left our civilization behind. And also further proof that the moon, and everything that surrounds it, is nothing more than an inflated toy.

Inspired by Bre's Moon crater, I thought, why not the whole moon?

This thing is a bump mapped sphere that uses the planetary map data/images from here:
johnstonsarchive.net/spaceart/cylmaps.html

Specifically, I used this one:
johnstonsarchive.net/spaceart/moonbumpmap2.jpg

I essentially used the same bump mapping technique I used on this bowl: thingiverse.com/thing:13991

That is, use the picture as a height map. Use that height map to displace the vertices around the sphere. At the same time, use the image to colorize the thing as well, if you want extra reality.

Now came the special part. Since I had the moon in my hands, I wanted to split it open and see what it was made of, answering that age old question once and for all.

So, I cracked it open, and found that it was in fact hollow! No green men, no Amazonian women, no cheese, nothing, just a void. Unlike answering the Easter Bunny question, this was quite a let down.

And lastly, since I was exploring the surface using MeshLab, I finally found the man in the moon. You can see him highlighted in red smiling back at us.

This has got to be great for science exploration!

A bit about the .stl files. I used Banate CAD to generate the models directly. The full moon has roughly 500,000 vertices, and double that in terms of faces. The partial moon has double the number of vertices because it has to generate the 'inside' as well as the outside. Each one took about 40-50 seconds to generate on my standard issue 3 year old Phenom II based machine. The generation time has more to do with the number of vertices than any other complexities. The routines create the normals for each face, whether they're needed or not, so this time could probably be cut in half in cases where you don't really need the normals, but it would not look nice when you render.

To generate any spherical thing, you would just change one line of code in the .fab file:

local heightsampler = ImageSampler.new({
Filename='moonbumpmap2_720_360.png',
Size = size,
Resolution = res,
MaxHeight=16,
})

Change "Filename = '...'",
to be whatever file you so happen to want to bump map.

This is the quick and dirty form of Bump/Height mapping. There are two things that should be done to improve the quality of such things. First, I'm doing a straight translation from the height map to a height value. What I should really be doing is taking an average, so you don't see such artifacting. The other thing is, for a sphere, there are better ways to apply a texture than to simply wrap the rectangle. By wrapping the rectangular image to the sphere, you lose something at the poles. I need better images which account for the spherical nature.

But hay, for changing just a single line of code, this is not a bad technique.

Not being very good with the UI 3D tools, but being good with the code... I wanted to create an interesting looking bowl, that had a height map as the texture of the surface.

This thing takes a procedural texture pattern (checkerboard) and uses that to create a height map, which is then used to displace the vertices of an ellipsoid.

It goes together rather nicely. And, since you can make a height map out of any image, you can get some very interesting effects going on.

One of the last extension libraries I wrote in OpenScad had to do with height maps.

This thing implements height maps in Banate CAD.

You can read the blog entry here: williamaadams.wordpress.com/2011/11/25/and-height-maps-for-all/

It's fairly straight forward in Banate CAD to do a height map from any image. It's actually the ImageSampler object that has the capability. You can then add this to this other object called a RubberSheet, and away you go!

You can also specify a thickness, so it's not just a surface, it's actually a solid.

The image with the purplish background is the generated mesh loaded into MeshLab. MeshLab was kind enough to remove the duplicate vertices for me. I'll have to do that within Banate CAD itself some day.

I need a funky saddle table.

This thing is the first 'solid' generated from Banate CAD directly, without the help of any other tools. I can at least open the .stl in GLCPlayer.

At the moment, I don't export normals so if your viewer can't deal with that, it will fail. Of course, things can only improve from here.

I generated this using a Bezier surface description:

local lshape3 = shape_bicubicsurface.new({
M=cubic_bezier_M(),
UMult=1,
Mesh = mesh,
Thickness = thickness,
USteps = 16,
WSteps = 16,
})
addshape(lshape3)

or more simply:

bicubicsurface{Mesh = mesh, Thickness = -3}


You can specify whatever thickness you want for the sheet. Using negative values will go 'in' from the normal vectors.

Of course, while in the renderer, you can texture map the thing just so you see something interesting while you're messing with your geometry.

UPDATE: Uploaded the .fab file

I uploaded my first design to Thingiverse on November 20th 2010. That first thing was a part from my "Klikko" play set: thingiverse.com/thing:4828

Since then, I've produced roughly 130 'things', many of which were iterations on core design explorations.

It's been fun. I've learned a lot about OpenScad, 3D modeling in general, and fallen in love with rapid prototyping and manufacturing.

I've taken all that I've learned to date, and created a new CAD program called Banate CAD. You can read about it here: williamaadams.wordpress.com/hum-banate/

As was once said about my Bezier work, I think I've 'rooted' CAD. It's wide open, easily extensible, can create anything you can describe with algorithms. It's almost as good as sliced bread.

It's seriously just a work in progress, although you can use it to do lots of pretty visualizations.

UPDATE: I have uploaded a copy of the program here as well. I have received at least one report that it works on Linux (Fedora 15), so that bodes well, considering I've never run it there myself.

The bowl_12.stl file here is of no consequence. It's just there because I could not create a thing with just a picture.

I want to mount metal bars onto wood, or other structures, without having to drill holes in the metal bars, or rather, I want to mount them with a bit of an offset.

This thing is a slight modification of the original. I added a taper to the mounting holes so that when I use screws with a taper, they won't split the plastic.

I was fiddling about with the SuperShape thing: thingiverse.com/thing:12770 and I 'discovered' this thing while playing around with various parameters.

This thing can be used as a scraper of some sort. I'm thinking to print one and use it as a pastry scraper, or something else in the kitchen.

I generated it using these parameters:

RenderSuperShape(
supershape(1, 0.3, 0.3, 0.3, 1, 1),
supershape(5, 15.4425, -0.453763, 87.07, 1, 1),
48,
32))

With those sharp edges, it might be quite challenging to print. I think it has a modern look to it, and it shows how kitchen items might be able to take on more of a flair, beyond the standard industrial looks.

I did in fact use OpenScad to generate the .stl, but I actually used Lua to generate the .scad in the first place, and that's not particularly interesting as yet, so the .stl is really no different than the .scad.

With different scalings, it can become something else like a flipper, rudder, or what have you.

I've been programming for quite a few years now, and since the beginning of time (programming my Commodore P.E.T.), I could not remember binary bit patterns to save my life!

This thing gives me the ability to print out binary representations of numbers. That gives me something nice and tactile that I can look at, pick up, and play around with.

Perhaps if I had this as a toy when I was younger, I would not have such problems remembering binary encodings because the memories would have been cemented in something physical.

Within the test_boolean.scad file, you will find the module: display_binary(number, bits, withplate)

You give it a number, and the number of bits you want to display, and whether you want a base plate attached or not.

And out comes your binary representation of your number.

If you care to look deeper, you can take a look at the boolean.scad file. In there you will find some useful bit banging operators like RSHIFT, LSHIFT, BIT, BTEST, 32BITAND, 32BITNOT, 32BITXOR, 32BITOR, and other boolean algebra thingies. These might be useful for other things some day.

In particular, you could perform an operation, and print the result of the operation tactally.

I have the need to mate a 1/4" thick piece of aluminum to a 1/2" round tubing. I need to be able to slide the mated aluminum along the tubing, and be able to lock it in place.

This thing is the tube connector, with a captured nut on the side.

Although somewhat related to this thing: thingiverse.com/thing:8356
It is not a strict derivative, but rather in the same family.

You can easily create a mashup of this thing and some other things, and get things sliding along tubes.

The fillet is on the bottom to help with reducing the amount of support material needed. It may not help at all depending on your printer. You can turn off the fillet, and simply get support under the overhang.

It is fully parameterized, so you can specify the size of the tubing, the length of the connector, and the size of the nut to be captured, as well as the number of facets that nut has (default 6).

It's Saturday, it's raining, there's work to be done!

After I posted that SuperShape stuff, user mattmoses pointed me at this site: steelpillow.com/polyhedra/five_sf/five.htm suggesting there are interesting space filling polehedra in the world that need to be turned into nicely printable models.

This thing is the one that came first, and that I could easily pronounce.

It's an interesting polyhedron in that it is self dual, meaning, it has 11 vertices, and 11 faces, so it can fit vertex to face, within itself, just like my favorite tetrahedron.

Mostly what is in this thing is a translation of the cartesian coordinates from that web site. I used their schematic to create the faces and edges. I could improve the edge selection so that it looks better when you're rendering in wireframe mode, but that can be an easy revision some time.

So, what's neat about this easily pronounced polyhedron? It's stackable!! That means, if you put a bit of stickyness onto the faces, you can stack these together and fill a space. Isn't that what Legos do? Yah, like that, except it's a much more interesting shape than a rectangle.

A long time back, when I was first learning to code in Windows, I rand the Charles Petzold digital clock application as a sample.

Since then, I've done everything with that clock from rendering in OpenGL to high resolution timers.

This thing takes the seven segment digital display and renders it in OpenScad.

It's pretty straight forward. There are three routines.
DisplayDigit(number, height) - Will display a single digit, centered at the origin.

DisplayDigits(numbers, count, height) - Will display a sequence of numbers, separated by a gap of 4mm.

RenderDigitsPlate(digits, count, thickness, height) - Will display a sequence of numbers, and put a nice rectangle underneath them in case you want to easily CSG the sequence of numbers with something else.

It's a bit hacky in that the gap between numbers is fixed, and I didn't normalize the polygon data, so it's a fixed size of 38x68. Of course you can scale it, but...

Well, there it is. finally off my chest. And now I have nice 7-segment numbers in the bag of tricks.

You can guess at the signifance of the number in the picture.

Continuing the madness... I was getting laughed at in my Design 101 class, so the only way I thought of to silence the other kids was to come out with my SuperShapes!

After having done the previous SuperEllipse work, it was just a matter of time before the formulas came knocking at my door wanting to be implemented.

This thing implements the SuperFormula (muwaaahhhaahaaahaaa)!!

What the heck is that? Best thing is to take a look at the pretty pictures at this web site: paulbourke.net/geometry/supershape3d/

If you're really a math nutter, then take a look at the math as well. It's actually not that complicated. The complication here is just turning the formula into something that can be dealt with by OpenScad. In particular, making sure the thing turns out to be 2-manifold, so that you can actually generate .stl files and print the results, therein lies the rub.

The supershape.scad files contains two rotines of interest:
RenderSuperShape2D() - This takes the definition of a single supershape, and renders the curve of that supershape in 2D, using wireframe. With this single routine, you can go to the wiki entry for Superfomula (http://en.wikipedia.org/wiki/Superformula) and plug in the various numbers, and see pretty pictures.

RenderSuperShape() - This takes two supershape definitions (one modulates the other), and renders real pretty pictures. You can look at the Paul Bourke site to get very interesting parameters to plug into that one.

Another source of parameters might be POVRay files.

That's enough for a Friday post I think.

But wait, there's more...

You also get the procedural texture mapping checkerboard pattern, thrown in for free. What is procedural texture mapping? Well, instead of using a bitmap to represent the different colors (or heights) on an object, you can just call a routine and ask it for the color at a particular position. No fus, no muss, no arrays to slow you down! At any rate, it's just a little hidden gem.

This code is public domain. I figure having such a nice routine freely available might encourage people to make some very interesting shapes.

Challenge: How the heck do you get OpenScad to display in wireframe, and with a fade on the other colors?

UPDATE: 22102011
Added the tristar.stl file. This was an experiment in rendering the 2D shapes with faces, and not just wireframes, then using them with CSG operations. The result is of course a deadly weapon once rendered in hardened steel and sharpened.

donb (http://www.thingiverse.com/donb) sent me a message recently about the SuperFormula (http://en.wikipedia.org/wiki/Superformula) as it reminded him of my other surface/solids work.

Recognizing the fun challenge, I thought I'd code it up. But, instead of starting right away with the SuperFormula, I thought I'd start with the SuperEllipse, which is very close, and a step along the way anyway.

This thing is an implementation of the SuperEllipse formula in OpenScad.

What good is a SuperEllipse? Well, it's actually a surface of revolution. With it you can define the ellipsoid, sphere, cylinder, cube/rectangle, and myriad other funky looking shapes that are somehwere in between these. It's great because from one formula you get all sorts of things. Just imagine if this were a primitive in OpenScad, as it is in things like PovRAY.

At any rate, the basic formulas are there. The fun thing is, you can render a point cloud if you want. That is, only the vertices, represented as tiny little spheres. You can also render as a wireframe. That's nice because you can see the structure, on the outside and the inside as well. Lastly, you can render as a polyhedron. Perhaps the most cool of all is that you could render as all three, at the same time, by just changing the values of some parameters.

The important file is superellipse.scad. With this one comes the 'superellipse()' module. This has parameters you can change to get the different shapes. Within the code, there is a reference to a page that gives examples with different parameters. By default, it renders with a radius of [1,1,1]. You can easily use the 'scale()' module to get a different size.

Although the thing will generate 2-manifold objects, it seems to be extremely expensive to do CSG operations on them.



UPDATE: I added another picture that shows a checkerboard pattern on it. That's a little bit of "precedural texture", which I haven't actually released as yet, but I thought it looked cool.

I am building a torsion box using corrugated plastic panel, and I find that I need a little someting to add rigidity to the joints.

This thing acts as a 'cap' for each of the joints in such a torsion box. It can be used without glue, or you can actually glue it in place.

The .scad has some easy parameters so you can select the gap size, and various lengths of things. Similarly, you can decide whether you want to have a hole in the middle of the thing, or not.

This particular project was inspired by a project in my daughter's art class.

NOTE: test_corners.scad is just for display purposes. There is nothing printable there really. It shows how the connector can be used in a torsion box construction.

GITHUB: github.com/Wiladams/TorsionBox

I needed the ability to quickly generate a tile from a height map. A height map is essentially a grayscale picture. If you think of each of the 'pixel' values representing a 'z' value for a vertex in a mesh, then you can imagine applying those z values, and what you get is a mesh transformed into a 'landscape'.

This thing is just a further refinement of the technique in OpenScad.

Although I am highlighting the technique by applying it to what looks like a landscape, I've also applied it to font rendering as well. There are a couple of ways of doing fonts in OpenScad. One is to use a 'bitmap' and essentially do height mapping, by representing each pixel as a cube.

Another method is to use the font information, and use the outlines to actually draw polygons and linear_extrude() them.

Yet a third way is to use a tool to export the font outlines into a .dxf file, and then load from there with a linear_extrude.

What you can do here is take the font, generate grayscale images of each character, in a format that is essentially OpenScad code. Then apply those images to a mesh, just like a landscape, and you've got extruded fonts!

The cool thing about this generalized technique is that you can use it for anything. The routine gives you absolute control over the size and resolution. So, for example, using the same basic grayscale image, you can print at 48x48 millimeters, with a resolution of 4 facets per millimeter. That would be great if you're printing on a machine with .25mm layer resolution. It would turn out fairly smooth. On the other hand, if you don't want to wait the hours required for that, you can simply change the resolution to be 1mm/facet, and still get a decent print.

The pictures here demonstrate the technique being applied to both terrain and characters.

There are two routines, which can be found in the MeshRenderer.scad file:
shell_extrude_height_map() - To be used when your height map information is represented by single values.

shell_extrude_color_map() - To be used when your height map information is still grayscale, but represented by triplets.

Oh yes, and one of the parameters to this routine: solid=true
That means that while you're prototyping, you can say 'solid=false', and it will simply generate a polygon surface. Then when you're done playing around, you can say 'solid=true', and you'll get a proper 2-manifold solid that you can then press 'F6' on and go take a walk.

I know, it's a lot of words, but look at the pretty pictures!! The 64x64 resolution mountain scene took 5 hours to render. The 48x48 took about 1.5 hours.

NOTE: Although I can easily generate single characters using this technique, actually generating them en masse as shown in the picture, has some problems. The structure ends of not being 2-manifold. I plan to improve the general text handling aspects later. But, the basic height mapping technique will remain the same.

I want to do height mapping in OpenScad. The easiest way to do it is to generate little cubes for each offset. That's a good start, but I wanted more. What I really want is the ability to layout a polyhedron mesh use a height map to alter the vertices of that mesh.

This thing is just the latest incarnation of the library. With it, you can do the following:

display_mesh_height([32,32], [2,2], heightmap=checker_image);

That is, specify a size in millimeters for the mesh [32,32], then a resolution [2,2], and the height map, our checker image.

The work is actually located in the test_mesh.scad file. It will do the height, but not do the color. That will come next.

Another thing that I'm doing in this incarnation of the library is separating out this thing called glsl.scad Basically, recognizing that there's a lot of stuff that I'm doing that mirrors what I would be doing in 3D graphics. A lot of this stuff is like vertex and shader programming, so I figured I'd model it in the same way. It also makes it easier to go from here (OpenScad) to rendering in something like the iPad.

Blog entry: williamaadams.wordpress.com/2011/09/25/openscad-texture-mapping-2/

GitHub: github.com/Wiladams/OpenScadModels/tree/master/Libraries

It's a paltry entry, but a nice way to do height maps. It takes up less resources to display the mesh than to display a bunch of cubes.

UPDATE:
OK, I got unlazy, and actually included the proper mesh renderer, so you can in fact make solid things from your bump maps.

Recently on the OpenScad discussion alias, I was trying to explain how I could do my own lighting calculations if given half a chance. Altough it's not really a possibility for the current OpenScad renderer, I got to thinking. Even though I can't print in multiple colors (yet), I can certainly liven up my OpenScad renderings a bit.

This thing is a set of imaging routines for OpenScad.

The general principle is fairly straight forward. First you need an image to be converted to a format that OpenScad can understand. In the included .zip file, there is such an executable. Just run:
ImageConverter.exe imagename > name.scad

This will generate something that looks like:
imagename_triplets_array = [0,0,0, 1,2,3, 255,255,255];
imagename = image(width, height, imagename_triplets_array)

There is a new function here: image() which takes parameters necessary to just package up some stuff for later usage in functions.

The crux of the routines is actually: image_getpixel(img, x,y)

This will return a color value at that point in the image. Nice and handy.

But, when you're using images of varying sizes, you don't use pixel coordinates directly, you use normalized values (between 0..1)

So, there is another routine: image_gettexel(image, u, v)

In this case, the 'u' and 'v' values range from 0..1

That's handy when you're displaying on a bezier surface for example, or a sphere, or anything else that's parametrically defined. You just need to supply the parametric values, and when you go to draw a particular facet, change the color for that facet, and voila!! You've got texture mapping.

Just for kicks, there is a luminance() function. What good is that? Well, that allows you to turn an rgb value into a single grayscale value. If you can do that, then you can't be that far away from having a height map generated out of an image.

Put it all together and you can take a picture of yourself, convert to OpenScad form, generate a height map, create a mesh that matches the height field (need to do some work for that one), and print out a 3D relief of your face!! Poor man's scan/print if you will.

At any rate, it's not complete, and you'll find that you use images of any significant size, your machine will crawl for literally hours.

But, if you go back and look at the various font libraries, where you're typically generating 'images' that are 16x12 or something small like that, then suddenly life becomes way easy.

If I were into actually contributing to the codebase of OpenScad, rather than just commenting on it, I would suggest that making the array lookups really fast to enable stuff like this without making the machine crawl, would be a very good investment.

UPDATE: 21092011
Added blog entry: williamaadams.wordpress.com/2011/09/21/openscad-texture-mapping/

The original was a good start, and good for a moldable form.

This thing represents some simple modifications to the original design to make it more easily printable. There are two primary changes.

1) There is now a central hub that is a cylinder instead of a sphere. This looks interesting, and serves to give a nice anchor point to the design.

2) The part that connects the flanges to the central part is now the same diameter as the widest part of the flange. That eliminates the largest 'overhang' part when printing on its 'side'

Other than that, the attached .stl files are for tubing that has a 5/16" inner diameter. It works great with vinyl tubing of that size. Wouldn't it be funny if someone filled those tubes with a hardening epoxy after connecting it into an interesting shape?

UPDATE: 07092011
Added a couple more pictures where the hubs are used as semi-rigid joints with vinyl tubing and wood dowels.

Way back in the day, my daughter and I wanted to build some simple structures using drinking straws. The typical method was to shove some paperclips into the ends, hook the paper clips together, and bit by bit assemble the structure. It was very hard, and until the whole structure was assembled, it remained frustratingly limp. I wanted a better way, and dreamed of having some tiny connectors that I could simply stick in the end of the straws and easily connect them. Then I got into ZomeTool and forget about the idea. Recently while cleaning out the house, I found the bundle of 1,000 straws I had purchased back then, which rekindled the spark of an idea I had back then. Now, armed with OpenScad skills, and a 3D printer...

This thing is finally that basic connector. But, it goes a bit beyond what I originally intended. These connectors are hollow, so you can actually use them to string bits and pieces of tubing together, and get liquid to flow between them.

This is very similar to the type of connector found in drip irrigation systems, like the ones found at Home Depot. They are called "barbed connector" there. You could probably also make the "speared" kind to dig into the thicker pipes.

Since these cost about $0.05 to print, and the store bought ones are more like $5, you might realize some amount of savings, if you're into creating these things.

I use straight angles here, so if you really were trying to form some structures, you might want to do the extra math to deal with angular defect. Or you could look at the library here: thingiverse.com/thing:9560 and dig out some of the math.

The .stl files here are meant to fit within the 6.25mm inner diameter drinking straws that I have here at home. You can simply change the OD value at the top of the file to mate with whatever 'tubing' you so happen to have. It will work great with vinyl tubing. A little dab of glue, and a tight fit, will make for a nice tight permanent structure.

Another fun thing might be to run some elwire through the tubes for a fancy display. Who knows. The possibilities are endless!

The OpenScad is included so you can make your own. For the elbows, just specify an angle. For the others, just specify how many connectors you want.

UPDATE: 05092011
Added blog entry here: williamaadams.wordpress.com/2011/09/05/useful-household-items-drip-irrigation-connectors/

After losing some hair over the issue, and with some help from Marius Kintel, I was finally enlightened as to why my dodecahedron was not coming out properly.

This thing represents some forms of the dodecahedron. In particular, it is combinations of the dual forms (dodecahedron/icosahedron). The .stl files are printed with a radius of 20mm, but you can change that to whatever you want either in the OpenScad, or by scaling.

The 'difference' form is probably the most interesting. It makes for a fairly decent calibration piece. It has some nicely sloping overhangs, bridges, and flat spots. I makes for some good tuning between ABS and PLA as well.

The challenge with the dodecahedron had to do with OpenScad not being happy with the pentagons I was trying to print. They had to be broken down into triangles, which Marius conveniently did for me.

In order to bake an apple pie...

I really am doing geodesic domes, but there's a long road I have to walk in order to get there.

This thing is the next incarnation of the geodesic library.

Being able to calculate strut lengths is one thing, and definitely a required step along the way to constructing geodesic domes. In fact, if you're just constructing them in the real world, the previous version of this library is enough, because you can calculate strut lengths and be on your merry way. But, if you what you're after is the ability to actually model the things and print them out, then you need a little bit more capabilities.

I found that I not only needed the list of vertices for a particular platonic solid, but I also needed edge lists. That is, a list of vertices that form edges. So, that's what's in this library. Otherwise, no dramatic changes.

I did add a polygon wireframe rendering module which takes the edge lists and renders a nice wireframe of the polyhedron in question. You can specify the radius of the 'wires'. I was toying with being able to render as flat faces as well, but that requires a lot more work than the simple approach I started out with (I am using my table saw to help me figure it out).

Since it's .scad files, you can alter them to suit your needs.

Based on several suggestions, I will likely stop using Thingiverse as my 'source repository', and put sources up on GitHub so they're more easily maintained. Then I can just drop model turds here when there's something interesting generated from the core libraries.

A funny thing happened on the way to developing geodesic stuff. I found that I needed to fully develop some Platonic solids. And since I needed to develop 3 of them, I figured I'd develop them all.

This thing represents the latest incarnation of the maths_geodesic library, plus extras.

First of all, the original maths_geodesic.scad library had a small bug in the 'clean' function which prevented it from properly converting spherical coordinates.

There are a few additions:
DEGREES() - Already exists in other libraries, convert from radians to degrees
RADIANS() - Already exists in other libraries, converst from degrees to radians

deg(deg,min,sec) - Creates a data structure that holds degrees, minutes, seconds
deg_to_dec(d) - converts from that degrees data structure to decimal form

These will come in handy some time when more spherical and geographic things start to show up.

sphu_from_cart(c, rad=1) - Does the same thing as sph_from_cart, but allows you to specify the radius. This is quite handy when you're converting from some cartesian coordinates, and you want to make something with a fixed radius.

then there's some things related to polygon math. Figuring out internal angles, and the like. Perhaps the most interesting is figuring out the dihedral angle for a platonic. That comes in handy for some calculations.

But, the really new stuff is the set of thing related directly to Platonic solids in the file 'platonic.scad'.

First of all, the 5 platonic solids are represented by functions that represent their geometry/topology, in a form suitable for rendering with the polyhedron() module.

So:
tetrahedron(rad=1)
octahedron(rad=1)
hexahedron(rad=1)
dodecahedron(rad=1)
icosahedron(rad=1)

You can use it like this:

display_polyhedron(icosahedron(20));

That will render a icosahedron centered at [0,0,0], with a radius of 20.

Being able to set the radius is really handy as you can do things like nest them, or simply create them to the size you need. The fact that they're centered on the origin makes it fairly easy to rotate them around, to whatever orientation you like.

The .stl files here just show some casual renderings that can be generated with the test_platonic.scad file. Doing truncations and stellations is fairly straight forward. Even doing hollowed out forms, particularly with duals, is fairly straightforward as well.

The only thing that's not here is using the inradius, circumradius, and midradius for doing proper alignment of duals. But, how hard could it be?

At any rate, OpenScad now has a tidy little set of Platonic solids to play with.

UPDATE: 19082011
I have added some .stl files that are renderings of the various solids. The Dodecahedron is actually having a problem in OpenScad. I will debug that one and upload it when it actually works. A very strange bug.

UPDATE: 03092011
Replaced the platonics.stl, with platonic_set.stl. I have a better dodecahedron now.