Comparison to PythonSCAD?

[ipsod]

Hi Jeff,

I've been looking into PythonSCAD lately: https://pythonscad.org/

It seems like they're trying to get a two-way integration between OpenSCAD and Python, instead of write-only. But, having interacted with the developer, I don't think they have much Python experience/expertise. I think they could really use your help.

I was hoping to hear an informed comparison of the two projects, if you know enough about PythonSCAD to compare.

[jeff-dh]

Hi,

thanks for the hint. I haven't seen it before. It looks interesting.

What are your thoughts about it?

On the first glance (from what I could see on the web) my impression was that the openscad integration is far better but the "user interface / api" does not seem to be as enhanced.

I'm gonna have a closer look at it.

[ipsod]

Exactly my thoughts. The main developer seems to be primarily a C developer who doesn't know much about Python's idioms, but, I think, under the hood, they've got something really cool going on. But, yeah, the API is not great, and the install process was atrocious (took over 3 hours to get all of the bugs worked out).

[jeff-dh]

That's this example with minor changes and it works

from openscad import cube, cylinder

def wheel():
    return cylinder(r=35, h=15, center=True).rotate([0, 90, 0])

def axle():
    a = cylinder(r=10, h=120, center=True).rotate([0, 90, 0])

    w1 = wheel().left(70)
    w2 = wheel().right(70)

    return w1 | w2 | a

def torso():
    bottom = cube([100, 250, 50], center=True)
    top = cube([80, 100, 60], center=True)

    window_cube = cube([200, 55 ,50], center=True).down(10)
    top -= (window_cube | window_cube.rotate([0, 0, 90]))

    return bottom | top.up(50)

def car():
    t = torso()

    front_axle = axle().down(20).back(80)

    rear_axle = axle().down(20).back(-80)

    return t | front_axle | rear_axle

car().show()

[ipsod]

It looks to have a pretty small surface area exposed. There's a .pyi file that was bundled, but I haven't figured out how to get my editor to use it.

/usr/local/share/openscad/libraries/python/openscad.pyi

stub file

```Python # PythonSCAD Stub File for use in editors like Visual Studio Code class PyLibFive: pass

class PyLibFive:
def x(self) -> PyLibFive:
"""Return X coorinate
"""
...

def y(self) ->PyLibFive:
    """Return Y coorinate
    """
    ...

def z(self) ->PyLibFive:
    """Return Z coorinate
    """
    ...

def sqrt(self, v) ->PyLibFive:
    """Return Z coorinate
    """
    ...

def square(self, v) ->PyLibFive:
    """ Calculates the square of v
    """
    ...

def abs(self, v) ->PyLibFive:
    """ Calculates the absolute Value of v
    """
    ...

def max(self, a, b) ->PyLibFive:
    """ Calculates the maximum from a and b
    """
    ...

def min(self, a, b) ->PyLibFive:
    """ Calculates the minimum from a and b
    """
    ...

def sin(self, v) ->PyLibFive:
    """ Calculates the sine of v
    """
    ...

def cos(self, v) ->PyLibFive:
    """ Calculates the cosine of v
    """
    ...

def tan(self, v) ->PyLibFive:
    """ Calculates the tangens of v
    """
    ...

def asin(self, v) ->PyLibFive:
    """ Calculates the arc sine of v
    """
    ...

def acos(self, v) ->PyLibFive:
    """ Calculates the arc cosine of v
    """
    ...

def atan(self, v) ->PyLibFive:
    """ Calculates the arc tangent of v
    """
    ...

def exp(self, v) ->PyLibFive:
    """ Calculates the exponent of v
    """
    ...

def log(self, v) ->PyLibFive:
    """ Calculates the logarithm of v
    """
    ...

def pow(self, a, b) ->PyLibFive:
    """ Calculates the power from a over b
    """
    ...

def comp(self, a, b) ->PyLibFive:
    """ Calculates the libfive comparision of a and b
    """
    ...

def atan2(self, y, x) ->PyLibFive:
    """ Calculates aractangent from y/x
    """
    ...

def print(self) ->PyLibFive:
    """ Print the Tree for debugging
    """
    ...

class PyOpenSCAD:
pass

class PyOpenSCAD:
def translate(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Move Object by an offset
"""
...

def right(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
    """Moves an Object to the right
    """
    ...

def left(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
    """Moves an Object to the left
    """
    ...

def back(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
    """Moves Object backwards
    """
    ...

def front(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
    """Moves Object frontwards
    """
    ...

def up(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
    """Move Object upwards
    """
    ...

def down(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
    """Move Object downwards
    """
    ...

def rotx(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
    """Rotate Object around X Axis
    """
    ...

def roty(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
    """Rotate Object around Y Axis
    """
    ...

def rotz(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
    """Rotate Object around Z Axis
    """
    ...

def rotate(obj:PyOpenSCAD, a:float, v:list[float]) -> PyOpenSCAD:
    """Rotate Object around X, Y and Z Axis
    """
    ...

def scale(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
    """Scale Object by a factor
    """
    ...

def mirror(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
    """Mirror Object 
    """
    ...

def multmatrix(obj:PyOpenSCAD, m:list[float]) -> PyOpenSCAD:
    """Apply an 4x4 Eigen vector to an Object or handle
    """
    ...

def divmatrix(obj:PyOpenSCAD, m:list[float]) -> PyOpenSCAD:
    """Apply inverse of an 4x4 Eigen vecor to an Object or handle
    """
    ...

def offset(obj:PyOpenSCAD, r:float, delta:float, chamfer:float, fn:int, fa:float, fs:float) -> PyOpenSCAD:
    """2D or 3D Offset of an Object
    """
    ...

def roof(obj:PyOpenSCAD, method:str, convexity:int, fn:int, fa:float, fs:float) -> PyOpenSCAD:
    """Create Roof from an 2D Shape
    """
    ...

def pull(obj:PyOpenSCAD, src:list[float], dst:list[float]) -> PyOpenSCAD:
    """Pull apart Object, basically between src and dst it creates a prisma with the x-section
    src: anchor
    dst: how much to pull
    """
    ...

def color(obj:PyOpenSCAD, c:str, alpha:float, texture:int) -> PyOpenSCAD:
    """Colorize Object
    texture: id from texture command
    """
    ...

def output(obj:PyOpenSCAD) -> None:
    """Output the result to the display
    """
    ...

def show(obj:PyOpenSCAD) -> None:
    """Same as output
    """
    ...

def export(obj:PyOpenSCAD, file:str) -> None:
    """Export the result to a file
    file:  output file name, format is automatically detected from suffix
    when obj is a dictionary, it allows 3mf export to export several paths
    """
    ...

def linear_extrude(obj:PyOpenSCAD, height:float, v:list[float], layer:str, convexity:int, origin:list[float], scale:float, center:bool, slices:int, segments:int, twist:float, fn:int, fa:float, fs:float) -> PyOpenSCAD:
    """Linear_extrude an 2D Object
    v: direction of extrusion
    """
    ...

def rotate_extrude(obj:PyOpenSCAD, layer, convexity:int, scale:float, twist:float, origin:list[float], offset:list[float], v:list[float], method:str, fn:int, fa:float, fs:float) -> PyOpenSCAD:
    """Rotate_extrude an 2D Object
    v: direction of extrusion
    """
    ...

def path_extrude(obj:PyOpenSCAD, path:list[float], xdir:list[float], convexity:int, origin:list[float], scale:float, twist:float, closed:bool, fn:int, fa:float, fs:float) -> PyOpenSCAD:
    """Path_extrude an 2D Object
    xdir: intial vector of x axis
    """
    ...

def resize(obj:PyOpenSCAD) -> PyOpenSCAD:
    """Resize an Object
    """
    ...

def highlight(obj:PyOpenSCAD) -> PyOpenSCAD:
    """Highlights Object
    """
    ...

def background(obj:PyOpenSCAD) -> PyOpenSCAD:
    """Puts Object into background
    """
    ...

def only(obj:PyOpenSCAD) -> PyOpenSCAD:
    """Shows only this object
    """
    ...

def projection(obj:PyOpenSCAD, cut:bool, convexity:int) -> PyOpenSCAD:
    """Crated 2D Projection from a 3D Object
    """
    ...

def mesh(obj:PyOpenSCAD):
    """Retrieves Mesh Data from a 2D or 3D object
    """
    ...

def oversample(obj:PyOpenSCAD,n:int, round:bool) -> PyOpenSCAD:
    """Create artificial intermediate points into straight lines
    n: factor  of the oversampling
    bool: whether to round the oversampling
    """
    ...

def fillet(obj:PyOpenSCAD, r:float, sel:PyOpenSCAD, fn:int) -> PyOpenSCAD:
    """Create nice roundings for sharp edges
    r: radius of the fillet
    sel: Object which overlaps the "selected" edges
    fn: number of points for fillet x-section
    """
    ...

def align(obj:PyOpenSCAD, refmat:list[float], objmat:list[float]) -> PyOpenSCAD:
    """Aligns an Object to another
    refmat: handle matrix of the reference object
    objmat: handle matrix of the new object
    """
    ...

def square(dim:float | list[float], center:bool) -> PyOpenSCAD:
"""Create a Square
"""
...

def circle(r:float,d:float,angle:float, fn:int, fa:float, fs:float) -> PyOpenSCAD:
"""Creates a Circle
"""
...

def polygon(points:list[float], paths:list[int], convexity:int) -> PyOpenSCAD:
"""Creates a Polygon
points: array of vertices
paths: how to combine them
"""
...

def text(text, size:float, font:str, spacing:float, direction:str, language:str, script:str, halign:float, valign:float, fn:int, fa:float, fs:float) -> PyOpenSCAD:
"""Creates a Text
"""
...

def textmetrics(text, size:float, font:str, spacing:float, direction:str, language:str, script:str, halign:float, valign:float) -> list[float]:
"""Get textmetrics from a label
"""
...

def cube(size:list[float], center:bool) -> PyOpenSCAD:
"""Creates a Cube
"""
...

def cylinder(h:float,r1:float, r2:float, center:bool, r:float, d:float, d1:float, d2:float, angle:float, fn:int, fa:float, fs:float) -> PyOpenSCAD:
"""Creates a Cylinder
"""
...

def sphere(r:float, d:float, fn:int, fa:float, fs:float) -> PyOpenSCAD:
"""Creates a Sphere
"""
...

def polyhedron(points:list[float], faces:list[int], convexity:int, triangles:list[int]) -> PyOpenSCAD:
"""Creates a Polyhedron
"""
...

def frep(exp:PyLibFive, min:list[float], max:list[float], res:int) -> PyOpenSCAD:
"""Create F-Rep (libfive)
exp : an SDF epression composed from SDF variables and operators, see tutorial
"""
...

def ifrep(obj:PyOpenSCAD) -> PyLibFive:
"""Create Inverse F-Rep(experimental)
"""
...

def translate(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Move Object by an offset
"""
...

def right(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Moves an Object to the right
"""
...

def left(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Moves an Object to the left
"""
...

def back(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Moves Object backwards
"""
...

def front(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Moves Object frontwards
"""
...

def up(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Move Object upwards
"""
...

def down(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Move Object downwards
"""
...

def rotx(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Rotate Object around X Axis
"""
...

def roty(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Rotate Object around Y Axis
"""
...

def rotz(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Rotate Object around Z Axis
"""
...

def rotate(obj:PyOpenSCAD, a:float, v:list[float]) -> PyOpenSCAD:
"""Rotate Object around X, Y and Z Axis
"""
...

def scale(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Scale Object by a factor
"""
...

def mirror(obj:PyOpenSCAD, v:list[float]) -> PyOpenSCAD:
"""Mirror Object
"""
...

def multmatrix(obj:PyOpenSCAD, m:list[float]) -> PyOpenSCAD:
"""Apply an 4x4 Eigen vector to an Object or handle
"""
...

def divmatrix(obj:PyOpenSCAD, m:list[float]) -> PyOpenSCAD:
"""Apply inverse of an 4x4 Eigen vecor to an Object or handle
"""
...

def offset(obj:PyOpenSCAD, r:float, delta:float, chamfer:float, fn:int, fa:float, fs:float) -> PyOpenSCAD:
"""2D or 3D Offset of an Object
"""
...

def roof(obj:PyOpenSCAD, method:str, convexity:int, fn:int, fa:float, fs:float) -> PyOpenSCAD:
"""Create Roof from an 2D Shape
"""
...

def pull(obj:PyOpenSCAD, src:list[float], dst:list[float]) -> PyOpenSCAD:
"""Pull apart Object, basically between src and dst it creates a prisma with the x-section
src: anchor
dst: how much to pull
"""
...

def color(obj:PyOpenSCAD, c:str, alpha:float, texture:int) -> PyOpenSCAD:
"""Colorize Object
texture: id from texture command
"""
...

def output(obj:PyOpenSCAD) -> None:
"""Output the result to the display
"""
...

def show(obj:PyOpenSCAD) -> None:
"""Same as output
"""
...

def export(obj:PyOpenSCAD, file:str) -> None:
"""Export the result to a file
file: output file name, format is automatically detected from suffix
when obj is a dictionary, it allows 3mf export to export several paths
"""
...

def linear_extrude(obj:PyOpenSCAD, height:float, v:list[float], layer:str, convexity:int, origin:list[float], scale:float, center:bool, slices:int, segments:int, twist:float, fn:int, fa:float, fs:float) -> PyOpenSCAD:
"""Linear_extrude an 2D Object
v: direction of extrusion
"""
...

def rotate_extrude(obj:PyOpenSCAD, layer, convexity:int, scale:float, twist:float, origin:list[float], offset:list[float], v:list[float], method:str, fn:int, fa:float, fs:float) -> PyOpenSCAD:
"""Rotate_extrude an 2D Object
v: direction of extrusion
"""
...

def path_extrude(obj:PyOpenSCAD, path:list[float], xdir:list[float], convexity:int, origin:list[float], scale:float, twist:float, closed:bool, fn:int, fa:float, fs:float) -> PyOpenSCAD:
"""Path_extrude an 2D Object
xdir: intial vector of x axis
"""
...

def union(obj:PyOpenSCAD, r:float, fn:int) -> PyOpenSCAD:
"""Union several Objects
r: radius of fillet
fn: number of points for fillet x-section
"""
...

def difference(obj:PyOpenSCAD, r:float, fn:int) -> PyOpenSCAD:
"""Difference several Objects
r: radius of fillet
fn: number of points for fillet x-section
"""
...

def intersection(obj:PyOpenSCAD, r:float, fn:int) -> PyOpenSCAD:
"""Intersection several Objects
r: radius of fillet
fn: number of points for fillet x-section
"""
...

def hull(obj:PyOpenSCAD) -> PyOpenSCAD:
"""Hull several Objects
"""
...

def minkowski(obj:PyOpenSCAD) -> PyOpenSCAD:
"""Minkowski sum several Objects
"""
...

def fill(obj:PyOpenSCAD) -> PyOpenSCAD:
"""Fill Objects(remove holes)
"""
...

def resize(obj:PyOpenSCAD) -> PyOpenSCAD:
"""Resize an Object
"""
...

def highlight(obj:PyOpenSCAD) -> PyOpenSCAD:
"""Highlights Object
"""
...

def background(obj:PyOpenSCAD) -> PyOpenSCAD:
"""Puts Object into background
"""
...

def only(obj:PyOpenSCAD) -> PyOpenSCAD:
"""Shows only this object
"""
...

def projection(obj:PyOpenSCAD, cut:bool, convexity:int) -> PyOpenSCAD:
"""Crated 2D Projection from a 3D Object
"""
...

def surface(file, center:bool, convexity:int, invert:bool) -> PyOpenSCAD:
"""Create a Surface Object
"""
...

def texture(file, uv:float):
"""Specify a Texture (JPEG) to be used with color
file: path to a jpg file
uv: size of the mapped texture square in 3D space
"""
...

def mesh(obj:PyOpenSCAD):
"""Retrieves Mesh Data from a 2D or 3D object
"""
...

def oversample(obj:PyOpenSCAD,n:int, round:bool) -> PyOpenSCAD:
"""Create artificial intermediate points into straight lines
n: factor of the oversampling
bool: whether to round the oversampling
"""
...

def fillet(obj:PyOpenSCAD, r:float, sel:PyOpenSCAD, fn:int) -> PyOpenSCAD:
"""Create nice roundings for sharp edges
r: radius of the fillet
sel: Object which overlaps the "selected" edges
fn: number of points for fillet x-section
"""
...

def group(obj:PyOpenSCAD) -> PyOpenSCAD:
"""Groups several Objects
"""
...

def render(obj:PyOpenSCAD,convexity:int) -> PyOpenSCAD:
"""Renders Object even in preview mode
"""
...

def osimport(file:str, layer:str, convexity:int, origin:list[float], scale:float, width:float, height:float, filename:str, center:bool, dpi:float, id:int) -> PyOpenSCAD:
"""Imports Object from disc
"""
...

def version() -> list[float]:
"""Outputs pythonscad Version
"""
...

def version_num() -> list[float]:
"""Outputs pythoncad Version
"""
...

def add_parameter(name:str, default) -> None:
"""Adds Parameter for use in Customizer
"""
...

def scad(code:str) -> PyOpenSCAD:
"""Evaluate Code in SCAD syntax
"""
...

def align(obj:PyOpenSCAD, refmat:list[float], objmat:list[float]) -> PyOpenSCAD:
"""Aligns an Object to another
refmat: handle matrix of the reference object
objmat: handle matrix of the new object
"""
...

</details>

[ipsod]

@jeff-dh gsohler/openscad#51

[jeff-dh]

I think we have a similar perspective.

I think one drawback is that I think it's hard to use pythonscad as python library from outside openscad, right? It's pretty tight couple to the openscad executable I assume.

I'm wondering whether it would make sense to implement kind of an intermediate representation interface for openscad that languages (like python) could use.
One the one hand this would give an interface for SolidPython like libraries for all languages and on the other hand it would enable to use a library like SolidPython withtout openscad and save it to this intermediate representation which would could later be rendered with openscad.

kind of a virtual machine for csg solids.....

[gsohler]

technically speaking, pythonscad uses an embedded python interpreter.
No, i did not code that myself, just used it.

[jeff-dh]

Is it possible that there's one and the same interpreter instance running all the time?

I had to restart openscad several times to reset the python interpreter (neccessary because of some python / openscad "compile errors" which seemed to be stuck in the session....)

is that possible?

[jeff-dh]

is it possible that reloading of python modules does not work properly?

I got a scad file which calls a function in a pythonscad file. If it once ran and I change the python file and run the scad file again nothing changes........ this is a well known issue with python

[jeff-dh]

If a python module once threw an exception while execution it seems that the interpreter is stuck afterwards throwing ERROR: Compilation cancelled by exception _Map_base::at

[ipsod]

I found that some exceptions are recoverable, like if I throw my own Exception in the file, but others weren't, like module not found. Maybe that's why you specify "if a Python module", though.

[jeff-dh]

it seems there already has been openscadpy several years ago....

[gsohler]

I have seen that, Unfortunately, this project is quite dead. It did not receive any latest updates of openscad like manifold and others

…

On Sun, Dec 15, 2024 at 7:24 PM jeff ***@***.***> wrote: it seems there already has been openscadpy <https://github.com/hmeyer/openscadpy> several years ago.... — Reply to this email directly, view it on GitHub <#71 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ACCO4MVGZWDD3VJEV3FS2RL2FXCNXAVCNFSM6AAAAABTOCT6ROVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTCNJXGM3DQMQ> . You are receiving this because you were mentioned.Message ID: ***@***.***>

[ipsod]

@jeff-dh gsohler/openscad#52
tagging you in case it's useful for you

[jeff-dh]

What about this:

from solid2 import cube
from openscad import output, scad

def output_solid2(obj):
    output(scad(obj.as_scad()))

output_solid2(cube(1).up())

That works! SolidPython ontop of pythonscad....

OpenScad is kind of the intermediate representation and pythonscad mimics the vm I was talking about earlier :D

[jeff-dh]

#############
#---> solid2.core.objet_base.object_base_impl.RenderMixin
#############
def output_solid2(obj):
    from openscad import output, scad
    output(scad(obj.as_scad()))

#hack to make it work out of the box
from solid2.core.object_base.object_base_impl import RenderMixin
RenderMixin.show = lambda self: output_solid2(self)

#############
#---- END
#############

from solid2 import cube

cube(1).down(2).show()

[ipsod]

Looks super cool. Glad you're looking at it, lol. Always impressed when I see how fast you do these things. Need one of those high-horsepower brains myself.

[jeff-dh]

some scad file:

use <solidtest.py>;

solidTest();

solidtest.py

from solid2 import sphere

def solidTest():
    from openscad import scad
    return scad(sphere(5).as_scad())

This does not work, but I assume it should work with little effort

[ipsod]

If you have a python file in the same dir, and you include it, and you later update that file, you have to restart OpenSCAD to get the update.

[gsohler]

This is a known "Feature" . Python uses cache files and you wont see the new content unless you clear the cache by e.g. restarting
There exists python code, which can clear the cache while running, but doubt thats available in SCAD language ;)
I think this should be fixed . maybe file a small testcase as issue to see exactly, how you are trying ? Make sure to include the exact steps what you are doing .

[gsohler]

SolidPython ontop of pythonscad.:
This is a good one! It uses SolidPython on top of PythonSCAD, but it uses PythonSCAD in SCAD language, Unfortunately really fancy features of PythonSCAD come with python mode.
Check out this one:

https://pythonscad.org/shared_designs/ea7907c7a3ee89ac61a86f72351892c1

its a basically just a sphere, but its radius is direction dependent, result supplied by a python function turning it into a nice sharp cornered cuocathaedron. It would be cool if that SolidPython could make openSCAd to do the same, but have small doubts

[ipsod]

Nice example. That's really weird.

[ipsod]

with show-edges turned on

[jeff-dh]

from solid2 import polyhedron
from icosphere import icosphere
from inspect import isfunction

def supersphere(r=1, fn=10):
    vs, fs = icosphere(fn)

    for i, v in enumerate(vs):
        if isfunction(r):
            vs[i] = v * r(v)
        else:
            vs[i] = v * r

    return polyhedron(vs, fs)

def rfunc(v):
    def dot(v1, v2):
        return v1[0]*v2[0]+ v1[1]*v2[1] + v1[2]*v2[2]

    def mydotmax(v, dirs):
        res = 0
        for dir in dirs:
            res = max(res, abs(dot(v, dir)))
        return res

    dirs=[[0.0,0.0,1.0],
        [1.0,0.0,0.0],
        [0.0,1.0,0.0],
        [0.5,0.5,0.5],
        [0.5,0.5,-0.5],
        [0.5,-0.5,0.5],
        [0.5,-0.5,-0.5],
        ]

    cf = mydotmax(v, dirs)
    return 10/pow(cf,1.5)

supersphere(rfunc, fn=50).save_as_scad()

[jeff-dh]

[ipsod]

Ok, that's the same thing, seemingly. What is that icosphere library?

I was hoping to get some of these measurements that openjscad has, like center of mass: https://openjscad.xyz/docs/module-modeling_measurements.html

Building a custom Python interpreter seems like a pretty heavy-handed way to get a few values out, though. Curious to see if there's more to it.

[jeff-dh]

What is that icosphere library?

a library from pypi that creates a mesh of a sphere
https://pypi.org/project/icosphere/

[gsohler]

python interpreter maintains a cache and its preferred over the source code when not cleared. you can clear the cache with some python commands

…

On Mon, Dec 16, 2024 at 12:19 AM jeff ***@***.***> wrote: Is it possible that there's one and the same interpreter instance running all the time? I had to restart openscad several times to reset the python interpreter (neccessary because of some python / openscad "compile errors" which seemed to be stuck in the session....) is that possible? — Reply to this email directly, view it on GitHub <#71 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ACCO4MVQXEFWTZITN5ENCTT2FYFB5AVCNFSM6AAAAABTOCT6ROVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTCNJXGUYTANI> . You are receiving this because you were mentioned.Message ID: ***@***.***>

[gsohler]

Way cool! This is basically also what I am doing :) Having the icosphere algorithm has (only) few advantages over your solution. i can expand the icosphere to next granularity dependent on the need(not necessary when absolutely flat) Also i remember that i put some effort to put the vertices very near to the resulting edge, so edges would ideally appear exactly sharp and not round I like your solution, though !

…

On Mon, Dec 16, 2024 at 11:10 PM jeff ***@***.***> wrote: from solid2 import polyhedronfrom icosphere import icospherefrom inspect import isfunction def supersphere(r=1, fn=10): vs, fs = icosphere(fn) for i, v in enumerate(vs): if isfunction(r): vs[i] = v * r(v) else: vs[i] = v * r return polyhedron(vs, fs) def rfunc(v): def dot(v1, v2): return v1[0]*v2[0]+ v1[1]*v2[1] + v1[2]*v2[2] def mydotmax(v, dirs): res = 0 for dir in dirs: res = max(res, abs(dot(v, dir))) return res dirs=[[0.0,0.0,1.0], [1.0,0.0,0.0], [0.0,1.0,0.0], [0.5,0.5,0.5], [0.5,0.5,-0.5], [0.5,-0.5,0.5], [0.5,-0.5,-0.5], ] cf = mydotmax(v, dirs) return 10/pow(cf,1.5) supersphere(rfunc, fn=50).save_as_scad() abcdef.png (view on web) <https://github.com/user-attachments/assets/5e5398f0-a362-4582-a822-6d8dbb4cf3b2> — Reply to this email directly, view it on GitHub <#71 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ACCO4MQLJBY57DFEWEPPLYL2F5FT7AVCNFSM6AAAAABTOCT6ROVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTCNJYGYZTSNQ> . You are receiving this because you were mentioned.Message ID: ***@***.***>