Does hull recalculate the edges and smooth out the math?

David

On 12/19/20 9:34 AM, adrianv wrote:

Hull doesn't round anything. It just takes all the vertices of the objects
and puts a skin around them. Imagine a rubber balloon stretched over a
bunch of sharp objects.

On Sat, 19 Dec 2020 at 20:45, David ainut@hiwaay.net wrote:

In the referenced polyhedra code (part of BOSL2) the vertices are computed
and the Linde user-space hull() function (not module) computes all of the
faces of the polyhedron.  I'm not sure if that's what the question was
about.  But it means that the polyhedra library doesn't have to know how to
construct the faces for all of the polyhedra, just the vertices, so that
simplifies things considerably.  The hull function takes a list of points
and computes the face list of the convex hull of the point list, which can
then be passed to polyhedron().

nophead wrote

--
Sent from: http://forum.openscad.org/

But I can't get the difference operator to shave the half cylinders.

Your strategy to get a shaved diamond is hard to debug because it resorts
to other vertices besides the diamond ones. I got it using just the 4
extreme diamond vertices:

module flattened_diamond()
intersection() {
scale(2)
// this is the hull of 4 diamond vertices with the origin
polyhedron( [[0,0,0],v[20],v[6],v[18],v[8],v[20]],
[ [0,2,1], [0,3,2], [0,4,3], [0,1,4], [1,2,3,4] ] );
diamond();
}

This shape, despite its name, has not a flat base and will need support for
3d printing. To get a flat base, the diamond needs to be elongated down and
chopped, a non trivial task.

Ideally I wanted them to snap together like lego bricks.

The shape above is unable to snap in another one. I devised some clips that
could keep the diamonds together at each vertex:

module clip6(r) {
rotFromTo(v[6],[0,0,1])
translate(-v[6])
difference() {
translate(v[6])
rotFromTo([0,0,1],v[6])
translate([0,0,-0.44r])
cylinder(r=r, h=0.7r,center=true);
full_skeleton();
}
}

module clip12(r) {
rotFromTo(v[20],[0,0,1])
translate(-v[20])
difference() {
translate(v[20])
rotFromTo([0,0,1],v[20])
translate([0,0,-0.58r])
cylinder(r=r, h=0.5r,center=true);
full_skeleton();
}
}

module clips() {
translate([0,0,0.443+0.73/2])
clip6(3);
translate([10,0,0.584.5+0.54.5/2])
clip12(4.5);
}

clips();

[image: Clips.PNG]

You're clearly down the road on your current approach, and no reason you need
to change if you're happy with it.  But you  might want to take a closer
look at the example I posted.  (Did you think about how big the 3d printer
would have had to be to print the example net in one model?)

The reason I posted that one and not the tetrahedron is that they print a
model much bigger for any normal printer in 13 pieces that snap together.
Presumably you could do the same for the shape you're interested in.  I
don't know the scale of what you're doing, but you could do it with 30
diamonds if they're huge or 12 "pentagons" (with 10 faces) if they're
smaller.

When talking about filament "waste" I'm not sure if you're referring to the
support material and brim needed to print the diamonds, or the total amount
of material needed to complete the project.  The fold up method uses no
support material at all, so in that sense, it's zero waste.  But I suspect
it would use more material than printing all the diamond frames, since it
includes the faces.  Hard to be sure because of all the support material you
need, but it seems likely.

Printing the whole skeleton is going to be very troublesome due to the
internal support material, unless you have a two material printer and can
print soluble support material.

Note that my point about trying to render the full skeleton is not that it's
a good model, but that it shouldn't crash openscad.  You shouldn't be able
to crash openscad by feeding it a nasty model.  Your comment about
duplicating rods doesn't even address the question of spheres at the
vertices, some of which are duplicated 20 times.  And I think the spheres
have more faces than the cylinders, so that's a much worse flaw in the
model.  Cutting the duplication to 10 (by fixing the rod duplication) still
leave a significant issue.

Another note:  you might want to fix the bug in rod() where it passes r1
instead of r.  This causes it to make a cone shaped rod if r1 isn't equal to
1.

rugyoga wrote

--
Sent from: http://forum.openscad.org/

adrianv wrote

Huh. So... this should work:

module badCube(){
polyhedron(points=[[-1,-1,-1],[1,1,-1],[-1,1,-1],[1,-1,-1],
[-1,-1, 1],[1,1, 1],[-1,1, 1],[1,-1, 1], [0,0,1.41]],
faces=[[0,1,2,3,4,5,6,7,8]]);
}

color("pink") translate([0,-3,0]) badCube();
color("lightblue") hull(){
badCube();
}

http://forum.openscad.org/file/t452/badCube.png

I was going to request the 'hull' function be slightly modified to take as
optional input a point cloud, but given that it seems to work with a polygon
object with a 'faces' argument that only needs to define the used points [in
any arbitrary order], creating a module that does that is fairly easy, e.g.

module hullPointCloud(points) {
hull()
{
echo([ for(i=[0:(len(points)-1)]) i]);
polyhedron(points=points, faces=[[ for(i=[0:(len(points)-1)]) i]]);
}
}

--
Sent from: http://forum.openscad.org/

Pay close attention to the difference between functions and modules.  The
hull() module is part of OpenSCAD.  The hull() function was written by Oskar
Linde and is included in the BOSL2 library.  It works on a list of points
and produces a list of faces.

Now as it happens, the thing you list below does work.  This was actually
discussed at length a while back.  Your method is suboptimal because it
creates a large complex face that may get triangulated by polyhedron()
before hull() runs, leading to long run time.  Instead you want to make a
bogus polyhedron with triangular faces:

module hull_points(points)
{
extra = len(points)%3;
faces = [
[for(i=[0:1:extra+2])i],  // Handle extra faces when vertex
count not divisible by 3
for(i=[extra+3:3:len(points)-3])[i,i+1,i+2]
];
hull() polyhedron(points=points, faces=faces);
}

I believe this version can produce warnings in some degenerate cases, which
may be a problem if you run OpenSCAD with "stop on first warning".

In contrast, the hull() function produces a face list as output, not
geometry.  You then invoke polyhedron to draw the polyhedron.  The problem
with the hull() function is that it's not very fast.  Doing 4000 points
takes about a minute.  The hack of hulling a bogus polyhedron is much
faster, since it exploits the built-in hull operator.

David Eccles (gringer) wrote

--
Sent from: http://forum.openscad.org/