So possibly self intersecting is fine as long as vertices don't coincide.
The topology is prerved through triangle soup when the vertices are all
unique.

On Mon, 17 Dec 2018 at 15:39, Parkinbot rudolf@digitaldocument.de wrote:

Does it allow boolean operations???

Parkinbot rudolf@digitaldocument.de wrote:

Ronaldo wrote

Yes, otherwise F10 wouldn't display a tesselation. Look at the code:

use <Naca_sweep.scad>
sweep([circle(), Tx_(3, circle(phi = 180))]);
function circle(r = 10, N=100, z=3, phi=0) =
[for(i=[0:N-1])  [rsin(360/Ni), rcos(360/Ni), zcos(360/Ni*2+phi)]];
cube(1);

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

Yes, I have observed before that a non-manifold polyhedron may be rendered.
The union of the cube with your shape renders without error unless the cube
intersect some self intersection areas of the shape. Try your example with
cube(16), for instance. You will get a CGAL error. And even when the cube
contains all your shape a CGAL error is issued. A strange shape (that
resembles to be a difference) results without error with cube(6).

Em seg, 10 de dez de 2018 às 20:07, Parkinbot rudolf@digitaldocument.de
escreveu:

Parkinbot,

The earcut method works fine with polygons with holes expressed as a unique
polygonal by bridging the holes and outer polygon by two-way bridges fully
inside the polygon interior. We just need to relax the ear test by
restricting it to the candidate ear interior. I have tested it with my
implementation of the ear method and it worked like a charm.

The remaining problem is to find the two-way bridges that connect all the
borders. The bridges in the runsun example are not allowed because they
cross other polygonal edges. I have found a paper (
https://www.geometrictools.com/Documentation/TriangulationByEarClipping.pdf)
that proposes a method to find those bridges. I have implemented the method
with good results. Here are two of them:

[image: PolyHoles2.PNG]
[image: PolyHoles1.PNG]

Find attached my implementation of the bridging method.

Ronaldo,

thanks, this sounds like a progress. Although the no cross restriction will
be difficult to guarantee in general when defining such a polygon, it seems
to be a step forward to implementing a fast multi-hole sweep like for
regular grids with fancy holes as shown in the example code attached. But to
be honest, meanwhile I dislike the implicitness of this representation. When
adding a new hole to a given object one will have to alter the whole polygon
sequence. This is very clumsy and makes me prefer the solution I already
characterized:

Parkinbot wrote

While this approach is a bit slower, it addresses an even larger class of
problems, since the multi-holes may even leave the outer body during the
sweep - which relaxes the no-mutual-intersection rule a bit. And it is easy
to add a new hole, because you just extend the vector describing the holes.

Nevertheless, if OpenSCAD offered a built-in lazy_union() operator, we
wouldn't have to discuss such things at all.

difference()
{
cube([100, 100, 5], center = true);
forXY(10, 10, 10, 10)
linear_extrude(5.01, center = true, twist=45, slices = 20)
square(6, center= true);
}

module forX(dx = 10, N=4) for($i=[0:N-1]) translate([-((N-1)/2-$i)*dx,0, 0])
children();
module forY(dy = 10, M=4) for($i=[0:M-1]) translate([0, -((M-1)/2-$i)*dy])
children();
module forXY(dx = 10, N=4, dy = 10, M=4) forX(dx, N) forY(dy, M) children();

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

Em qua, 9 de jan de 2019 às 12:45, Parkinbot rudolf@digitaldocument.de
escreveu:

I understand your point but I see a very simple and general way to overcome
it.

Suppose we have a lazyUnion operator with the following header:

module lazyUnion(<list of objects>)

where the objects in the parameter list are given in a polyhedron data
format, that is, a pair of vertex list and face list. This module is easy
to be coded by:

1. concat in one list all vertices of all objects;
2. displace (by a fixed amount) the indices of the face list of an object
   to agree with the new order of the concatenated vertex list;
3. call polyhedron with the new vertex list and the concat of the updated
   face list.

Usually we think to lazy-union manifold objects but this may be generalized
to lazy-union a set of surfaces that will enclose one (or many) manifold.
Surely, we need to assure manifoldness of the result to have a proper
object for CGAL. The ground of this generalization is that OpenSCAD
aggregates multiple vertices with the same coordinates as one vertex as I
mentioned 2 years ago (
http://forum.openscad.org/Can-you-sweep-a-object-with-fingers-tp19057p19203.html
).

With that in mind, the sweep of a polygon with holes may be structured as:
a) individually sweep each polygonal border of the outer polygon and of the
holes without their caps returning the result in a polyhedron data format
(a simplification of the current sweep codes);
b) triangulate the sweep ends of polygons with holes and generate its
result in a polyhedron data format;
c) call lazyUnion with the list of the above data.

As a final touch, each function which generates polyhedron data format
should have an additional parameter to promote, when needed, the reversion
of all its faces. This parameter, with default false, may be set true when
a Thrown Together view shows an incorrect orientation of that surface.

lazyUnion thought as such has many other uses as the reference I gave above
illustrates.

When facing cases where the swept holes leak out the outer sweep, then uses
the slower boolean method.