Surface-Oriented CAD, Math, & Telescopes

surfcad is a python proof-of-concept CAD library I’ve been writing for what I call “surface-oriented CAD”.

The idea came to me when I realized that some of things I’d been trying to make in openscad, a CSG based CAD program, would have been much easier to do in the software I’d written for making models of mathematical objects (eg. this model of a solution the diffusion equation). In this software, surface were constructed based on mathematical functions. One had to think to make sure that their object was closed, but it was possible to describe things that would have been prohibitively difficult in a CAD program like openscad.

A Cylinder

from surfcad import *

s = cylinderical_surface(lambda t,h: 10, 50)

f=STLFile("test.stl")

f.add(s.surface())
f.add(s.top_loop().close())
f.add(s.bottom_loop().close())

f.end()

To see what is going on, lets break it down a little:

f.add(s.surface())

f.add(s.top_loop().close())

So you see how we break it down.

Transforms

cylinderical_surface(lambda t,h: 3, 5)

scale([6,8,6])*cylinderical_surface(lambda t,h: 3, 5)

twistz(0.1)*(scale([6,8,6])*cylinderical_surface(lambda t,h: 3, 5))

twistz() begins to demonstrate the raw potential of transforms in surfcad. Basically, you can do any continuous transformation you can imagine (well, actually, in some cases the limiting factor will be your ability to describe the function in python, rather than your imagination…).

Coolness and Joinings

We can do much more interesting surfaces than the one describe above. The following is a minimal surface in Minkowski space (to make this more interesting, in string theory, strings are supposed to sweep out surfaces in Minkowski space), suggested to me by my Real Analysis professor, Robert Jerrard. (I don’t really understand why it works, but the general solution looks eerily similar to the solution to the wave equation, and I’ve been told it is not a coincidence).

cylinderical_surface(lambda t,h: (20.*(cos(t+h)-1/5.*cos(-5.*(t-h))), 20.*(sin(t+h)-1/5.*sin(-5.*(t-h))),20*h), 1.25)

Rather than giving it a boring old solid top, lets make it a thin hollow tube.

To do this, we’ll put a shrunk version in the middle, and then join the top loops to each other and the bottom loops to each other.

from surfcad import *

s = cylinderical_surface(lambda t,h: (20.*(cos(t+h)-1/5.*cos(-5.*(t-h))), 20.*(sin(t+h)-1/5.*sin(-5.*(t-h))),20*h), 1.25)
s2 = scale([0.8,0.8,1.])*s

f=STLFile("out.stl")
f.add(s.surface())
f.add(s2.surface())
f.add(join(s.top_loop(), s2.top_loop()))
f.add(join(s.bottom_loop(), s2.bottom_loop()))
f.end()

A slightly modified version of this (scaled to be printable) is on thingiverse.

As another example of what surfcad can do, I’ve posted code to generate the real and imaginary components of the first few nomials on the complex unit circle on thingiverse.

Some Technical Musings

(You can skip this part if you wish)

The fact of the matter is that I don’t have enough time to implement all the things I should. The following are some of these.

Firstly, the present version has resolution as a constant parameter across all objects. Clearly, that shouldn’t be the case. While it being constant does make the implementation of loop.close() and join() simpler, it is possible to do them without.  You just have to be willing to have multiple points on the higher resolution loop correspond to a single one on the simpler one.

Another place things fall apart is in the naivety of my present algorithms for closing and joining loops. For closing, they should at least be radially connected, preferably convex. And joining has a host of issues involving the alignment of the loops.

It’s also worth noticing that, fundamentally, every surface is just a map from one of [0,1]², S₁×[0,1], or S₁² into ℝ³. This allows for a lot of abstraction, at least into theory.

Something else that I keep thinking of  is a haskell implementation. 3D objects could be a monad, allowing for something like

cylinderical_surface :: ( (Real, Real) -> Real ) -> Real -> Object (Loop, Loop)
s = cylinderical_surface(...)
obj = do { (a1, a2)            (b1, b2)            join a1 b1
           close a2
           close b2
         }

Does any of this have practical applications?

Actually, yes. One advantage to this approach is that it makes it easy to describe surfaces that would be difficult to construct in a CSG modeling program.

So I decided to 3D print a Newtonian telescope to demonstrate how useful this could be. You see, a Newtonian telescope internally uses parabolic mirrors instead of lenses. With the sort of precision a makerbot or reprap prints at, the linear interpolation from sanding a surface should be a good enough parabola for a decent mirror.

(Normally a Newtonian telescope would need a lens in the eyepiece, but I think I can deform the secondary mirror to avoid this. Although, I think you could make a lens by printing a water soluble negative and filling it with epoxy.)

The only trick, I thought, would be making the mirror shiny. As it turned out, that was much more difficult than I expected. In fact, I still haven’t come up with a good enough solution. Spray paint isn’t shiny enough and tinfoil crinkles. Alas, my 3D printable vacuum cleaner, designed in openscad, remains the coolest thing I’ve made.

I’ve received all sorts of awesome suggestions around hacklab, from spinning mercury to floor wax. Norman even offered to silver it for me!

None of the ones I’ve tried so far worked, and I want a solution that anyone can do, so that anyone with a 3D printer can easily make a telescope. What do you think, Internets?

Tags: 3d printing, CAD, math, telescopes