Indeed, that performance is really awful.  Turning on the experimental
vertex-object-renderer features helps a lot.  For me, that alone took
preview performance on your model from unusable to sort-of-usable. 
But still...

The first thing is easy.  Repeat this mantra:  use $fn only to create
regular polygons.  To control circle quality, use $fa and $fs.  $fa=2
/ $fs=1 seems like a reasonable setting here.

Also:  screens are high resolution and really show faces.  3D printing
much less so.  If you turn up your circle quality enough that your
displayed model looks really smooth, you probably have way more faces
than you really need for 3D printing.  Experiment. Note also that you
can set the circle quality to some medium level while you're working,
and to high quality for your final render.

But that still leaves the preview performance pretty poor.

That leads us to a second and more difficult mantra:  never do in 3D
what you can do in 2D.

You have the basic shape of the coin being a torus unioned with a
cylinder, with a sphere subtracted.  But that's the same as a circle
unioned with a rectangle, with a circle subtracted, all
rotate-extruded.  The shape that would be rotate-extruded is this:

That gets you the body of the coin, without anywhere near as many
nasty 3D operations.  (In particular, it avoids that big sphere with
its thousands and thousands of faces - in your design, it has ~26,000
faces.)

Similarly, you have cutout() being a cylinder with a torus
subtracted.  But that's the same thing as a rectangle with a circle
subtracted, rotate-extruded.  The shape that you are rotate-extruding is:

Also, you have a convexity problem on the linear-extruded text.  A
convexity of four is probably enough, but five is definitely enough.

All that done, the performance gets pretty good.

Here's a preview of your model:

Here's a preview of mine:

Mine is a little lower circle resolution on the outside.  My bet is
that the difference isn't visible in 3D printing, but experiment with
$fs.  Setting $fs=0.5 looks like it's better resolution than yours,
but it gets significantly slower (not so much with the vertex-object
stuff turned on).  Experiment with an actual printer.  (Yours has 28K
facets.  Mine with $fs=1 has 10K; with $fs=0.5 has 23K.)  Here's mine
with $fs=0.5:

On my system (i7-13700), yours F6-renders in 1m6s; mine with $fs=1
renders in 15s; with $fs=0.5 in 54s.  But with the experimental
Manifold renderer, they're all sub-second.  (Manifold is magic.)

If one wanted to optimize further, note that cutout() is a fully
cylindrical object, and only a small fraction of it is actually used
for the subtraction.  You could use rotate_extrude's angle parameter
to only generate maybe a quarter of it.  Those invisible negative
faces have a preview cost (and probably a rendering cost too).  But
that seems like overkill.

Anyhow, there's some ideas.  Here's my version.

$fa = 2;
$fs = 1;
innendd= 6;
akr=5;
kr=20;
exr = 14;

maker_coin(r=kr, or=akr, innerh=innendd, exd=exr) {
linear_extrude(height=2*akr, convexity=5)
text("OS", size= 10, halign = "center", valign = "center");
}

// r= radius of the coin- outercircle diam, inner height
module maker_coin(r, or, innerh, exd) {
difference() {
maker_coin_body(r=kr, or=akr, innerh=innendd, exd=exd);
translate([0,0,2]) children();
}
}

module maker_coin_body(r, or, innerh, exd) {
resth = 2or-innerh;
bigd = (r^2+resth^2)/resth; //euklidischer Höhensatz·
difference() {
union() {
rotate_extrude() {
difference() {
union() {
square([r, 2or]);
translate([r,or])circle(r=or);
}
translate([0,bigd/2 + innerh]) {
circle(d = bigd);
}
}
}
}
union() {
for(w=[0:360/8:360]) rotate([0,0,w])
translate([r+2*or,0,-.1]) cutout(r=r, or=or, exd=exd);
}
}
}

module cutout(r, or, exd) {
rotate_extrude() {
difference() {
square([0.75exd, 2or + 2]);
cutr = or+0.2;
translate([exd/2+cutr,cutr-0.2])
circle(r=cutr);
}
}
}

OpenSCAD mailing list
To unsubscribe send an email todiscuss-leave@lists.openscad.org

Indeed, that performance is really awful.  Turning on the experimental
vertex-object-renderer features helps a lot.  For me, that alone took
preview performance on your model from unusable to sort-of-usable.  But
still...

The first thing is easy.  Repeat this mantra:  use $fn only to create
regular polygons.  To control circle quality, use $fa and $fs.  $fa=2 /
$fs=1 seems like a reasonable setting here.

That leads us to a second and more difficult mantra:  never do in 3D what
you can do in 2D.

You have the basic shape of the coin being a torus unioned with a
cylinder, with a sphere subtracted.  But that's the same as a circle
unioned with a rectangle, with a circle subtracted, all rotate-extruded.
The shape that would be rotate-extruded is this:

that's also exactly what Angus did :'(

That gets you the body of the coin, without anywhere near as many nasty 3D
operations.  (In particular, it avoids that big sphere with its thousands
and thousands of faces - in your design, it has ~26,000 faces.)

Similarly, you have cutout() being a cylinder with a torus subtracted.
But that's the same thing as a rectangle with a circle subtracted,
rotate-extruded.

Also, you have a convexity problem on the linear-extruded text.  A
convexity of four is probably enough, but five is definitely enough.

in 15s; with $fs=0.5 in 54s.  But with the experimental Manifold renderer,
they're all sub-second.  (Manifold is magic.)

If one wanted to optimize further, note that cutout() is a fully
cylindrical object, and only a small fraction of it is actually used for
the subtraction.  You could use rotate_extrude's angle parameter to only
generate maybe a quarter of it.  Those invisible negative faces have a
preview cost (and probably a rendering cost too).  But that seems like
overkill.

:

Hello all,
will still work on that for

• limiting the cutouts to the necessary angles as Jordan suggested
• and have to somehow add the x/y bevel to the cutouts,

in the meantime, i put it up here:
https://github.com/nohkumado/opensource_makercoin for review,
validation suggestions (i used the images you kindly provided, Jordan,
hope that's ok?), and in a few day i will try to push it onto Angus :D

thanks!

Am Sa., 2. März 2024 um 08:59 Uhr schrieb Bruno Boettcher
bboett@gmail.com:

 Hello Jordan!

 wow... thanks a lots for the very detailed analysis!


 Am Fr., 1. März 2024 um 21:00 Uhr schrieb Jordan Brown
 <openscad@jordan.maileater.net>:

     Indeed, that performance is really awful.  Turning on the
     experimental vertex-object-renderer features helps a lot.  For
     me, that alone took preview performance on your model from
     unusable to sort-of-usable.  But still...

     The first thing is easy.  Repeat this mantra:  use $fn only to
     create regular polygons.  To control circle quality, use $fa
     and $fs.  $fa=2 / $fs=1 seems like a reasonable setting here.

 ok, indeed :D looks bad on the screen but you are right, the
 printer hasn't that good of a resolution....


     That leads us to a second and more difficult mantra: never do
     in 3D what you can do in 2D.

 will try to keep that in mind :D


     You have the basic shape of the coin being a torus unioned
     with a cylinder, with a sphere subtracted. But that's the same
     as a circle unioned with a rectangle, with a circle
     subtracted, all rotate-extruded.  The shape that would be
     rotate-extruded is this:

 that's also exactly what Angus did :'(


     That gets you the body of the coin, without anywhere near as
     many nasty 3D operations.  (In particular, it avoids that big
     sphere with its thousands and thousands of faces - in your
     design, it has ~26,000 faces.)

 ok, think i get it.....


     Similarly, you have cutout() being a cylinder with a torus
     subtracted.  But that's the same thing as a rectangle with a
     circle subtracted, rotate-extruded.

 hmmm since we are at it... a hint how to integrate directly also
 the horizontal bevels to that shape?



     Also, you have a convexity problem on the linear-extruded
     text.  A convexity of four is probably enough, but five is
     definitely enough.

 oh.... never looked into convexity, but noticed the ugly artifacts...

     On my system (i7-13700), yours F6-renders in 1m6s; mine with
     $fs=1 renders in 15s; with $fs=0.5 in 54s. But with the
     experimental Manifold renderer, they're all sub-second. 
     (Manifold is magic.)

 my system is definitely slower :D but nevermind, your version
 clearly is the one to go with! thanks!



     If one wanted to optimize further, note that cutout() is a
     fully cylindrical object, and only a small fraction of it is
     actually used for the subtraction. You could use
     rotate_extrude's angle parameter to only generate maybe a
     quarter of it.  Those invisible negative faces have a preview
     cost (and probably a rendering cost too).  But that seems like
     overkill.

 nope, will look into that! seems logical..
 but as said i still need to add also in x/y plane the bevel, and
 not really knowing how to achieve that....

 anyway thanks a lot, i will put this up later on github, for
 further enhancements and review!
 thanks a lot!

 -- 
 ciao
 Bruno

 

---==========
http://nohkumado.eu/,
http://bboett.free.frhttp://aikido.nohkumado.eu/,
http://bboett.free.fr
http://aikido.zorn.free.fr

--
ciao
Bruno

---==========
http://nohkumado.eu/,
http://bboett.free.frhttp://aikido.nohkumado.eu/,
http://bboett.free.fr
http://aikido.zorn.free.fr

OpenSCAD mailing list
To unsubscribe send an email todiscuss-leave@lists.openscad.org

nope, will look into that! seems logical..

It is an optimiztation, that if it is unnecessary, you really
shouldn't do. You're complicating a "cylinder" into rotate-extruding
over a specific angle that comes out of nowhere.

If you're reading that code a couple of years from now the simple
cylinder is much easier to understand than "why the BEEP do you need
to rotate extrude that over that specific angle".

The other things are structural, the way you build it up kind of
things. The way you THINK about it changes, but it doesn't really get
more complicated.

 Similarly, you have cutout() being a cylinder with a torus
 subtracted.  But that's the same thing as a rectangle with a
 circle subtracted, rotate-extruded. 

hmmm since we are at it... a hint how to integrate directly also the
horizontal bevels to that shape?

 Also, you have a convexity problem on the linear-extruded text.  A
 convexity of four is probably enough, but five is definitely enough.

oh.... never looked into convexity, but noticed the ugly artifacts...

the expected result is what Raymond West got with the minkowsky
transform! In the picture he posted you see that his cylindrical
cutouts are smoothed in all planes.

The shape of the coin profile is wrong.
The circular cutout intersects the rim at the top, but it should
intersect further in, where the two circles have matching angles on
the rims. The transition should not be detectable.

Can the fillets be modelled as sections of cylinders, or circular
extruded from circles?

If so, make a negative 'form' for the rim of the coin, and use those
cylinders and extrusions, together with a cylinder for the cutout
itself, and use that with a DIFFERENCE operation to cleanly make the
cutouts.

Hi Trygve,

Thanks for looking.

On 04/03/2024 07:41, Gadgetman! via Discuss wrote:

The shape of the coin profile is wrong.
The circular cutout intersects the rim at the top, but it should
intersect further in, where the two circles have matching angles on
the rims. The transition should not be detectable.

it's a function of the $fn. In my code I commented it out in the
profiles, so that it would render this side of Easter. If the same low
resolution image is good enough for printing, then a slight adjustment
to  the line  ' translate ([0,53.14]) circle(r=47.15); // need to
calculate' in profile 2  module will eliminate the ridge. If you
comment out the last line ( done() ) and uncomment the  '//
profile();', you will see the jagged profile. If you then uncomment
the '//$fn =90;'  in the profile module you get a smoother profile.
Because there are both large and small radii, the resolution achieved
by the '$fn' values is  'not a one size fits all', and this was posted
as a work towards a solution.  As is, may be good enough for a  fdm
print. Without the attempt at filleting,It can be made smoother than a
smooth thing using openscad with a $fn =1000, (just 'cos we  can!).

An alternative could be to forget the the large recess/curve/scallop
in the profile, and then difference a large smooth sphere just before
the text addition. Many ways of getting a result.

Can the fillets be modelled as sections of cylinders, or circular
extruded from circles?

If so, make a negative 'form' for the rim of the coin, and use those
cylinders and extrusions, together with a cylinder for the cutout
itself, and use that with a DIFFERENCE operation to cleanly make the
cutouts.

That was my initial thought, I made a slim section of the interface of
the notch and the rim, (the ' bit=0.1' was left over from that ) - the
notch being  larger by twice the fillet, the rim being the small rim,
and then simply Minkowski that shape. However, adding that into a
suitably notched full size rim gave problems with non manifold
rendering, etc. I may return to that.

Best wishes,

Ray

OpenSCAD mailing list
To unsubscribe send an email to discuss-leave@lists.openscad.org

I was a little annoyed that Angus ignored OpenSCAD in his YouTube review
of free CAD solutions for 3d printing.

Here's my attempt at a coin using the new metaballs() function in the
BOSL2 library for OpenSCAD.    The version pictured is an F6 render that
took about a minute and a half.
If you increase voxel_size to 1 in line 10, it takes about 15 seconds for
an F6 render.

include <BOSL2/std.scad>
include <BOSL2/isosurface.scad>
h1 = 10;
r1 = 25;
r2 = 5;
d1 = r1 * 2;
isovalue = 1;
voxel_size = 0.5;
infl = 0.2;
cut = 10;
function tmat(ang) = move(cylindrical_to_xyz(r1,ang,0));
difference() {
metaballs([
IDENT, mb_disk(h1,r1),
up(r1-2), mb_sphere(r1*4, influence = 1, negative = true, cutoff = r1+2),
for (ang = [0:45:315])
each [tmat(ang), mb_sphere(r2, influence = infl, negative = true, cutoff =
cut)]
],
voxel_size, [[-d1,-d1,-h1], [d1,d1,h1]], isovalue);
text3d(h = h1/2, "BOSL2", size = 4, center = true);
}

OpenSCAD mailing list
To unsubscribe send an email to discuss-leave@lists.openscad.org

I was a little annoyed that Angus ignored OpenSCAD in his YouTube review
of free CAD solutions for 3d printing.

Here's my attempt at a coin using the new metaballs() function in the
BOSL2 library for OpenSCAD.    The version pictured is an F6 render that
took about a minute and a half.
If you increase voxel_size to 1 in line 10, it takes about 15 seconds for
an F6 render.

include <BOSL2/std.scad>
include <BOSL2/isosurface.scad>
h1 = 10;
r1 = 25;
r2 = 5;
d1 = r1 * 2;
isovalue = 1;
voxel_size = 0.5;
infl = 0.2;
cut = 10;
function tmat(ang) = move(cylindrical_to_xyz(r1,ang,0));
difference() {
metaballs([
IDENT, mb_disk(h1,r1),
up(r1-2), mb_sphere(r1*4, influence = 1, negative = true, cutoff = r1+2),
for (ang = [0:45:315])
each [tmat(ang), mb_sphere(r2, influence = infl, negative = true, cutoff =
cut)]
],
voxel_size, [[-d1,-d1,-h1], [d1,d1,h1]], isovalue);
text3d(h = h1/2, "BOSL2", size = 4, center = true);
}

OpenSCAD mailing list
To unsubscribe send an email to discuss-leave@lists.openscad.org

below is the python code and it takes around 19 sec to calculate:

from openscad2 import *
i_t=time.time()