sdf

That feature requires getting pyopenvdb installed, which can be a headache, and I never really updated the README with examples, but it does work. There is one example script: https://github.com/fogleman/sdf/blob/main/examples/mesh.py You basically just say: f = Mesh.from_file(path).sdf(voxel_size=0.25, half_width=1) Then you can operate on `f`.

It is kinda neat, but OpenSCAD's limitations are the main thing that motivated me to write this Python library to generate 3D meshes used signed distance functions: https://github.com/fogleman/sdf One big plus to doing it this way is that it's "just" Python and you can use arbitrary logic to help construct your model. You can even load an existing 3D mesh and operate on it as an SDF. Great for hollowing, chopping, eroding/dilating, etc. existing models. I should probably do more with this project. I think there's a lot of interest in this space.

Mostly speed, I'm mostly doing large boolean unions of primitives or chain hulls and OpenSCAD chugs pretty good at large numbers of operations. Don't get me wrong, they're great tools for what they're good at. I need to do more research before I start a port, SDFs seem like the best option but I'm not 100% confident. I am considering using your SDF library though (github.com/fogleman/sdf) but need do do some experimenting/benchmarking first.

This is a little hobby/side project i've been working on . Its tool for constructive solid geometry using python which runs in your browser (best viewed on desktop). The gist of it is it runs in your browser(pyodide) you write high level python which generates the corresponding glsl for your objects signed distance function which is then rendered using webgl (raymarching). The objects can then be converted to an STL (marching cubes) and downloaded while SDF's for csg has been done before , https://github.com/fogleman/sdf , it requires you to generate the mesh and view it in a seperate viewer . Here instead i render the sdf with a fragment shader onto a canvas. Python is neat, a lot of people know it or can pick it up fast and i thought its the perfect language for small time 3d printing hobbyist or designers to quickly conjure something u

I used to like OpenSCAD for its simple approach but then I discovered SDF-based modelling with Python made possible with this neat library: [1]. This is perfect if you are a programmer that doesn't know anything about CAD-Software. 1.: https://github.com/fogleman/sdf

At the moment you don't. What I'm suggesting is that you could build up a conventional BREP-based datastructure, and than use SDF to "render" it. This gives you a very clear separation between your data structure and your meshing algorithm, and as I understand it a big chunk of those "100 man years" would be in dealing with the meshing algorithm and edge cases in it. I suspect that having a generic meshing algorithm that will always mesh your datastructure with no edge cases would significantly reduce the time needed to implement a CAD kernel. You just need an algorithm that can tell you if a given point is inside or outside of your BREP. All you really need for that is a surface that points at a given direction, and the ability to tell whether a point is under the surface or not. Define your surfaces as BREP, render them using SDF, only

>these the the central core that understands BREP and implements the geometric operations. I've seen people quote a good modern CAD kernal as a 100 man year project. It's probably not going to happen, maybe there's some avenue for government funding? Alternatively Signed-Distance-Functions are pretty nice. They're not BREP, but they're a lot easier to implement, and it might be possible to shove them into a BREP-shaped hole. Here's a signed-distance-function based CAD kernal written in a few thousand lines of python+numpy, that seems to be about as fast as openscad. Maybe faster. https://github.com/fogleman/sdf

Excellent. You might be interested in a Python library that I wrote for generating 3D meshes (STL files) from SDFs : https://github.com/fogleman/sdf It just uses marching cubes for triangulation but the SDFs are all numpy'd and the SDF is evaluated in batches on multiple threads so it's relatively fast. I wrote it because I was a little frustrated with OpenSCAD. SDFs make it trivial to do things like rounded corners, for example.

Try out fogleman/sdf[1]. It is like OpenSCAD in many ways but the distance field model gives you offsets and fillets more easily. [1] https://github.com/fogleman/sdf

Just a quick diff between your list and mine, apologies if I missed them or if there is a reason to exclude these: - https://github.com/nickc92/ViewSCAD - Matt Keeter's stuff (listed here https://www.mattkeeter.com/projects/, including https://github.com/mkeeter/antimony and https://www.mattkeeter.com/projects/ao/, though I see you have libfive) - https://solvespace.com/index.pl - https://mirmik.github.io/zencad/en/ - https://github.com/fogleman/sdf This is from a list entitled "migrate away from OpenSCAD", but somehow I can never manage to do that... Thanks for this site!

> Basic things like 'hollow this object out, leaving a 3mm shell' are nearly impossible. Yeah, I think that's a consequence of how they're constructing the objects. But things like signed distance fields make that easier* because it'd just be "expand the SDF by 3mm" - https://github.com/fogleman/sdf has `shell` for this. * if you can wrap your head around the math/geometry, I guess

> https://github.com/fogleman/sdf Holy crap, why have I not seen this before?!?!!? I was even planning to start coding something like this myself. This is awesome! Thanks!!!!

> Which I reckon is me being too used to cli-tools and hardly ever going outside the cli world You might get some mileage out of OpenSCAD if you can define your object parametrically (I used it to make a Switch controller middle-bit.) Or there's stuff like https://github.com/fogleman/sdf which I've used to make resin-printed buttons for my mother. (I also cannot get the hang of Blender despite dipping into it for a couple of weeks every year since about 2013.)