Some timing tests of the Python API.

[briansturgill]

Recently, I was concerned that the union done at the create of a CrossSection could be a problem.
I was completely wrong. From the timing test below and some other experimentation,
I can say that for < 100 vertices the overhead is somewhere between 2.5 and 5.
And everything is so fast, you'd have to be really huge to even notice
I can see no reason for a need to drop to C++ to make CrossSections.

Surprisingly, creation of round rects with hull and 4 circles is quite practical, even for large numbers.

And finally batch_boolean is 2 orders of magnitude faster on a large data set.

All of this was 2D. I'll likely do something for 3D later.

(Times [left column] are in seconds.)

 0.375 1,000,000 creations of CS with square member function
 1.906 1,000,000 creations of CS with points from square
 11.554 1,000,000 creations of roundrect using hull and 4 circles
 0.595 Creation of 1,000,000 randomly placed roundrect
 7.625 1000 unions of 1000 randomly placed roundrect
 0.268 batch_boolean union of 10,000 randomly placed roundrect

import time
import manifold3d as m
from random import random

ts = time.perf_counter()
for i in range(1000000):
    c = m.CrossSection.square((10.0, 10.0))
te = time.perf_counter()
tdiff = te - ts
print(f"{tdiff: 5.3f}", "1,000,000 creations of CS with square member function")

p = c.to_polygons()
ts = time.perf_counter()
for i in range(1000000):
    c = m.CrossSection(p)
te = time.perf_counter()
tdiff = te - ts
print(f"{tdiff: 5.3f}", "1,000,000 creations of CS with points from square")


r = 5
s = 36
ts = time.perf_counter()
for i in range(1000000):
    circ = m.CrossSection.circle(r, s)
    c = m.CrossSection.batch_hull(
        [
            circ,
            circ.translate((10, 0)),
            circ.translate((0, 10)),
            circ.translate((10, 10)),
        ]
    )
te = time.perf_counter()
tdiff = te - ts
print(f"{tdiff: 5.3f}", "1,000,000 creations of roundrect using hull and 4 circles")

l = []
ts = time.perf_counter()
for i in range(1000000):
    c = c.translate((random() * 1000, random() * 1000))
    l.append(c)
te = time.perf_counter()
tdiff = te - ts
print(f"{tdiff: 5.3f}", "Creation of 1,000,000 randomly placed roundrect")

c1 = m.CrossSection()
ts = time.perf_counter()
for i in range(1000):
    c1 = m.CrossSection.__add__(c1, l[i])
te = time.perf_counter()
tdiff = te - ts
print(f"{tdiff: 5.3f}", "1000 unions of 1000 randomly placed roundrect")

ts = time.perf_counter()
c = m.CrossSection.batch_boolean(l[:10000], m.OpType.Add)
te = time.perf_counter()
tdiff = te - ts
print(f"{tdiff: 5.3f}", "batch_boolean union of 10,000 randomly placed roundrect")

[elalish]

Thanks! Of course that's pretty all the Clipper2 lib anyway - I'll be quite interested to see what you find for 3D, since that's our code.

[briansturgill]

@elalish OK, you got me curious, so I did the 3d version.

The reason the creation from mesh is shorter is that the mesh is a mesh object. Still, clearly fast enough.

3d hull time is bad, not sure what it is that makes 3d hulls so much harder than 2d hulls.
Still, fast enough.

But WOW, the batch_boolean time.
It took me a long time to believe the results were true.
I really thought my test was faulty.
In the end I saved the output of the batch_boolean and looked at it with mesh lab. (178,000 vertices).
So Google's quantum computing initiative is going better than publicly said and you're secretly hooking into it? :-)

Anyway, here's the result's:

 1.333 100,000 creations of M with cube member function
 0.843 100,000 creations of M with mesh from cube
 3.536 1,000 creations of roundedbox using hull and 8 spheres
 0.070 Creation of 100000 randomly placed roundedbox
 3.365 10000 unions of 10000 randomly placed roundedbox
 0.009 batch_boolean union of 100000 randomly placed roundedbox

import time
import manifold3d as m
from random import random

ts = time.time()
for i in range(100000):
    c = m.Manifold.cube((10.0, 10.0, 10.0))
te = time.time()
tdiff = te - ts
print(f"{tdiff: 5.3f}", "100,000 creations of M with cube member function")

mesh = c.to_mesh()
ts = time.time()
for i in range(100000):
    c = m.Manifold(mesh).to_mesh()
te = time.time()
tdiff = te - ts
print(f"{tdiff: 5.3f}", "100,000 creations of M with mesh from cube")


r = 5
s = 36
ts = time.time()
for i in range(1000):
    sph = m.Manifold.sphere(r, s)
    c = m.Manifold.batch_hull(
        [
            sph,
            sph.translate((10, 0, 0)),
            sph.translate((0, 10, 0)),
            sph.translate((10, 10, 0)),
            sph.translate((0, 0, 10)),
            sph.translate((10, 0, 10)),
            sph.translate((0, 10, 10)),
            sph.translate((10, 10, 10)),
        ]
    )
te = time.time()
tdiff = te - ts
print(f"{tdiff: 5.3f}", "1,000 creations of roundedbox using hull and 8 spheres")

n = 100000
l = []
ts = time.time()
for i in range(n):
    c1 = c.translate((random() * 200, random() * 200, random() * 200))
    l.append(c1)
te = time.time()
tdiff = te - ts
print(f"{tdiff: 5.3f}", f"Creation of {n} randomly placed roundedbox")

c1 = m.Manifold()
ts = time.time()
for i in range(n//10):
    c1 = m.Manifold.__add__(c1, l[i])
te = time.time()
tdiff = te - ts
print(f"{tdiff: 5.3f}", f"{n//10} unions of {n//10} randomly placed roundedbox")

ts = time.time()
c = m.Manifold.batch_boolean(l, m.OpType.Add)
te = time.time()
tdiff = te - ts
print(f"{tdiff: 5.3f}", f"batch_boolean union of {n} randomly placed roundedbox")

[pca006132]

No, they are lazy evaluated, you need to force evaluation by invoking something like .mesh()

[briansturgill]

I'm not sure I understand, do you mean:
c = m.Manifold(mesh).to_mesh()?
If so that increased time to 0.822

[elalish]

Yes; technically that also does some work to write out the result, though not much. You can also call really simple things like NumVert(), which will also force evaluation.

Would you mind starting a summary thread of your results in #383? It's a nice central place to see performance numbers.

[briansturgill]

@pca006132 @elalish I updated the numbers and the code above.
I was needlessly making multiple identical circles/spheres in the rounded rect/box tests.
Also, I bumped up the number of rounded boxes being unioned as batch_boolean timings were often 0.

[pca006132]

I think for the batch union, you are probably triggering our fast path as most of them have no intersection. Anyway, hope that you are happy with the performance :)

[briansturgill]

Moving this to #383 (as requested).
I've improved the timing tests greatly, so ignore the numbers above.