To reproduce:

from sdf import *
f = slab()

Output:

  File "example.py", line 3, in <module>
    f = slab()
  File "C:\Users\Brandon\Documents\GitHub\sdf\sdf\d3.py", line 49, in wrapper
    return SDF3(f(*args, **kwargs))
  File "C:\Users\Brandon\Documents\GitHub\sdf\sdf\d3.py", line 133, in slab
    return intersection(*fs, k=k)
  File "C:\Users\Brandon\Documents\GitHub\sdf\sdf\d3.py", line 54, in wrapper
    return SDF3(f(*args, **kwargs))
TypeError: intersection() missing 1 required positional argument: 'a'```

I am unable to recreate the displacement example from https://iquilezles.org/www/articles/distfunctions/distfunctions.htm

My attempt

diff --git a/sdf/d3.py b/sdf/d3.py
index 237c1cd..44829c5 100644
--- a/sdf/d3.py
+++ b/sdf/d3.py
@@ -500,6 +500,16 @@ def wrap_around(other, x0, x1, r=None, e=ease.linear):
         return other(q)
     return f
 
+@op3
+def displace(other):
+    def f(p):
+        x = p[:,0]
+        y = p[:,1]
+        z = p[:,2]
+        d2 = np.sin(20*x)*np.sin(20*y)*np.sin(20*z)
+        return other(p) + d2
+    return f
+

results in

 % python3 test.py
Traceback (most recent call last):
  File "test.py", line 10, in <module>
    f.save('out.stl')
  File "/vanfiles/repos/sdf/sdf/d3.py", line 43, in save
    return mesh.save(path, self, *args, **kwargs)
  File "/vanfiles/repos/sdf/sdf/mesh.py", line 152, in save
    points = generate(*args, **kwargs)
  File "/vanfiles/repos/sdf/sdf/mesh.py", line 92, in generate
    bounds = _estimate_bounds(sdf)
  File "/vanfiles/repos/sdf/sdf/mesh.py", line 77, in _estimate_bounds
    volume = sdf(P).reshape((len(X), len(Y), len(Z)))
ValueError: cannot reshape array of size 16777216 into shape (16,16,16)

Any tips on getting this to work?

Dual contouring is a meshing technique which is better at producing sharp corner than marching cube.

Do you think the technique would be suitable in this case? I've been looking for excuse to play with it. Is it something you already working on? If not I'm calling dibs

A cone without end caps would be really useful.

I tried to roll my own, but it seems not quite as straightforward as I expected - I'm unsure of exactly how the vectorised maths should be handled.

For my purposes it would be ideal if it had the same interface as rounded_cone if that's possible, i.e. cone(r1, r2, d) should produce a vertically-oriented cone that has a radius of r1 at z=0 and r2 at z=1.

Inigo Quilez gives the following function for the exact sdf of an infinite cone, in case this helps. I got stuck because the vectors 'q' and 'c' have different dimensions due to vectorisation, so I don't know the efficient way to dot them together.

float sdCone( vec3 p, vec2 c )
{
    // c is the sin/cos of the angle
    vec2 q = vec2( length(p.xz), -p.y );
    float d = length(q-c*max(dot(q,c), 0.0));
    return d * ((q.x*c.y-q.y*c.x<0.0)?-1.0:1.0);
}

Cool library! I was just reading your code and noticed you call marching_cubes on subsections of the SDF, but I don't see any "stitching" code when you put the subsections back together. Doesn't that lead to lots of extra triangles on the inside of the mesh on the subsection boundaries? Just wondering if you could explain how this works :)

This is a bit of a noob question, but is there a way to install this library instead of running in a virtualenv? After following the install instructions I can run the examples, but I can't work out how to import the library into code that's not located in the source folder.

(I know my way around Python pretty well, but I'm an academic rather than a developer and have never used virtualenv.)

Hi ! I have ran your examples (examples.example.py), which seemed to work well. However, saved STL file was empty, with no information stored in it, as Meshlab didn't show anything.

Here's logs I've got (base) D:\Source\Research\sdf>python examples/example.py min -0.84543, -0.84543, -0.84543 max 0.845431, 0.845431, 0.845431 step 0.0104847, 0.0104847, 0.0104847 4657463 samples in 216 batches with 16 workers 100% (216 of 216) [##############################] 0:00:00 0:00:00 44 skipped, 172 empty, 0 nonempty 0 triangles in 0.442999 seconds

It says I have 0 triangles.

$ python examples/example.py

Traceback (most recent call last):
  File "examples/example.py", line 1, in <module>
    from sdf import *
  File "/Users/jimmygunawan/sdf/sdf/__init__.py", line 1, in <module>
    from . import d2, d3, ease
  File "/Users/jimmygunawan/sdf/sdf/d2.py", line 5, in <module>
    from . import dn, d3, ease
  File "/Users/jimmygunawan/sdf/sdf/dn.py", line 7
    def union(a, *bs, k=None):
                      ^
SyntaxError: invalid syntax

Wonderful work, but I stumbeled over the following:

import sdf
screw_hole =  sdf.capped_cylinder(0, 10, 6)
screw_hole.save('out.stl', workers=1) 



-------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
c:\Work\kufe.py in 
      28 import sdf
      29 screw_hole =  sdf.capped_cylinder(0, 10, 6)
----> 30 screw_hole.save('out.stl', workers=1)

c:\work\sdf\sdf\d3.py in save(self, path, *args, **kwargs)
     41         return mesh.generate(self, *args, **kwargs)
     42     def save(self, path, *args, **kwargs):
---> 43         return mesh.save(path, self, *args, **kwargs)
     44     def show_slice(self, *args, **kwargs):
     45         return mesh.show_slice(self, *args, **kwargs)

c:\work\sdf\sdf\mesh.py in save(path, *args, **kwargs)
    150 
    151 def save(path, *args, **kwargs):
--> 152     points = generate(*args, **kwargs)
    153     stl.write_binary_stl(path, points)
    154 

c:\work\sdf\sdf\mesh.py in generate(sdf, step, bounds, samples, workers, batch_size, verbose, sparse)
     90 
     91     if bounds is None:
---> 92         bounds = _estimate_bounds(sdf)
     93     (x0, y0, z0), (x1, y1, z1) = bounds
     94 

c:\work\sdf\sdf\mesh.py in _estimate_bounds(sdf)
     75         prev = threshold
     76         P = _cartesian_product(X, Y, Z)
---> 77         volume = sdf(P).reshape((len(X), len(Y), len(Z)))
     78         where = np.argwhere(np.abs(volume) <= threshold)
     79         x1, y1, z1 = (x0, y0, z0) + where.max(axis=0) * d + d / 2

c:\work\sdf\sdf\d3.py in __call__(self, p)
     23         self.f = f
     24     def __call__(self, p):
---> 25         return self.f(p).reshape((-1, 1))
     26     def __getattr__(self, name):
     27         if name in _ops:

c:\work\sdf\sdf\d3.py in f(p)
    190         baba = np.dot(ba, ba)
    191         paba = np.dot(pa, ba).reshape((-1, 1))
--> 192         x = _length(pa * baba - ba * paba) - radius * baba
    193         y = np.abs(paba - baba * 0.5) - baba * 0.5
    194         x = x.reshape((-1, 1))

ValueError: operands could not be broadcast together with shapes (4096,3) (12288,1) 

OS: Debian 10 Python 3.7.3

python3 example.py

min -0.84543, -0.84543, -0.84543 max 0.845431, 0.845431, 0.845431 step 0.0104847, 0.0104847, 0.0104847 4492125 samples in 64 batches with 8 workers 0 triangles in 0.741009 seconds

Running the pawn.py example fails. I followed the steps in the README and used virtualenv and pip as suggested.

All other examples work for me.

$ python examples/pawn.py
Traceback (most recent call last):
  File "examples/pawn.py", line 8, in <module>
    f = section(0, 0.2, 1, 1.25)
  File "examples/pawn.py", line 4, in section
    f = cylinder(d0/2).transition(
  File "...../sdf/sdf/d3.py", line 30, in __getattr__
    raise AttributeError
AttributeError

Any idea what causes this?

Hello developers,

I would like to calculate the total volume of an arbitrary sphere based SDF object. For now I am casting the SDF to a mesh and then use that to calculate the volume. However, writing the mesh is by far the most expensive step. I guess this is mainly due to the marching cubes. I was wondering if there is a way to get the volume from the voxels generated for the marching cubes directly. Or even better get the 'analytical' volume of the SDF without going to voxels at all?

Cheers and thanks in advance.

Bart

PS If we get this working we will probably write a small algorithm about it and if you are interested you can partake in this publication. We can talk about the details later.

Dear developer,

I am trying to convert a point cloud to an SDF object. I have an array of XYZs. I have been trying the following:

from sdf import *

def place_bead(x, y, z, size):
    """
    Creates a SDF sphere of given size at the 
    indicated position.
    """
    bead = sphere(size)
    bead.translate(X*x)
    bead.translate(Y*y)
    bead.translate(Z*z)
    return bead

# Setting some sphere properties
size = dict()
aa_names_list = ['oxygen', 'hydrogen', 'carbon']
aa_sizes_list = [.152, .120, .170]
size_dict = dict(zip(aa_names_list, aa_sizes_list))

# Generating some data, the goal is a some spheres on a line. However
#  this will be practically random XYZs in the real case.
aa_xpositions = np.arange(100)
aa_ypositions = np.zeros(100)
aa_zpositions = np.zeros(100)
aa_types = np.random.choice(aa_names_list[:3], 100)
aa_sizes = np.asarray([size_dict[aa_type] for aa_type in aa_types])
aa_array = np.vstack([aa_xpositions, aa_ypositions, aa_zpositions, aa_sizes]).T
aa_objects = [place_bead(*bead) for bead in aa_array]

# Generating the unified SDF
s = aa_objects[0]
for aa_object in aa_objects[1:]:
    s.union(aa_object)

However, I always end up with just a single sphere. Also it feels pretty convoluted, but as I am only aiming at small point clouds for now (for sure less than a 1000) I do do not worry too much about the performance.

It would be great if you could nudge me in the right direction.

Cheers,

Bart

Thank you for the wonderful starting pad. I've been working on making this useful for doing machining work for my workbench, and thought I should present all the changes to you for your review

from sdf import *

f = sphere(1) & box(1.5)

c = cylinder(0.5) f -= c.orient(X) | c.orient(Y) | c.orient(Z)

f.save('out.stl', step=0.002)

Encounter divide problem when step=0.002 or 0.001

i get an array from existing stl by numpy-stl.Maybe i need a function and then decorate with @sdf3,i want to know how to return ?i look the source code like sphere ,i am confused what kind of value to return.array?