Hi, Lord Asriel. You said "it would be better if I could actually make a
large array of vertices, and the just read the memory instead of
calculating each vertex 6 or even 3 times."

But polyhedron already works the way you want. You can pass your "large
array of vertices" as the "points" argument, separate from the "faces"
argument, which contains indices into the points array. I haven't noticed
any problem caused by having extra points that aren't referenced by "faces".

I find it a bit disturbing that OpenSCAD can successfully load an STL file
containing a polyhedron that is too big to describe directly using the
polyhedron() command. That suggests a problem in the implementation that
maybe could be fixed.

Maybe if you posted your code, we would have a better understanding of what
is going wrong.

Doug Moen.

Indeed the polyhedron functionality is satisfying. The point is, how can I
make a large vertex array to pass it. Like, 1000 elements. Or, even
better, of x elements, where x is a variable.

I here provide a code to see a simplified example of what I'm doing.
Severely increasing phi_n means a severe increase in faces:

phi_n=50;
function foobar(phi) = 2+cos(phi);
dphi=360/phi_n;

for(phi=[0:dphi:360-dphi])
{
curr=[foobar(phi)*cos(phi),foobar(phi)*sin(phi),5]; //current
next=[foobar(phi+dphi)*cos(phi+dphi),foobar(phi+dphi)*sin(phi+dphi),5];
bottom=[0,0,0];
top=[0,0,10];

polyhedron(
points=[bottom,curr,next,top],
faces=[[0,1,2],[3,2,1]]
);
}

--
View this message in context: http://forum.openscad.org/Vertex-arrays-tp15876p15954.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

I checked the 3d example out.
Before discussing if it is an answer or not, let me state that it is
difficult to understand. This list thing feels very simplar to prolog-which
is a serious headache. Making tools user-unfriendly doesn't seem very good
practice. Mildly agreesive answering implying not investing time to read
around seems misplaced to me.

Now that scad file's main idea, if I do get it, is to create point as
list[listx[],listy]?
Why would that produce the needed [[x1,y1,z1],[x2,y2,z2]....] and not
[[x1,x2...],[y1,y2...]0?

And I don't know where to find scad-utils/lists.scad

--
View this message in context: http://forum.openscad.org/Vertex-arrays-tp15876p15958.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

A more specific example...

This needs the development version which allows multiple list
generators in a single expression.
With the release version, it would need to use concat() to
collect the multiple lists into a single one.

phi_n = 50;

function foobar(phi) = 2 + cos(phi);
function point(phi) = [ foobar(phi) * cos(phi), foobar(phi) * sin(phi), 5 ];

points = [
for (i = [0:phi_n - 1]) point(i * 360 / phi_n),
[0, 0, 0],
[0, 0, 10],
];

faces = [
for (i = [0:phi_n - 1]) [ phi_n, i, (i + 1) % phi_n],
for (i = [0:phi_n - 1]) [ phi_n + 1, (i + 1) % phi_n, i]
];

polyhedron(points, faces);

I don't see a huge syntax issue actually. Generating polyhedrons
directly is not going to be the easiest thing, regardless of the
actual syntax used.
I think the example above is as simple as it gets for this
specific model.

ciao,
Torsten.

OpenSCAD, like Prolog, is a declarative language. In Prolog, rules return
true or false, whereas in OpenSCAD, modules return a 3D object. It takes a
bit of mind twisting to get into the swing of declarative programming, but
I've learnt to stop worrying and love the recursion.

As an example, my path extrusion script generates a polyhedron formed by
translating and rotating a polygon along a path in three-dimensional space.
Here's a double helix, created as a polyhedron with about 180 defined
points. Modifying the number of slices of 't' for the point and path
function can result in this quite quickly exceeding 1000 points without any
change in code:

use <path_extrude.scad>;
pi=3.14159;
for(shift = [0, 360/15]){
myPoints = [ for(t = [0:72:359]) [cos(t),sin(t)] ];
myPath = [ for(t = [0:10:359]) [
(10+1.212pisin(5t))cos(t+shift),
(10+1.212pisin(5t))sin(t+shift),
1.212picos(5*t)
] ];
path_extrude(points=myPoints, path=myPath, merge=true);
}

I've included an image with an 18-point circle and 180-point path for
demonstration.

http://forum.openscad.org/file/n15969/pathextrude_double_helix_3240.png

The backend of the path_extrude function is 4kb of code, which is fairly
lightweight when compared to things that it can replace. It uses list
comprehensions to simplify the code, but I can achieve the same thing by
defining a function to generate recursive vectors (see my EllerSCAD maze
generator for an example of that). I use a recursive function to first
generate the point array:

module path_extrude(points, path, pos=0, merge=false, trimEnds=false,
extruded=[]){
if((len(points) > 0) && (len(path) > 0)){
if(len(extruded) >= (len(path))){
// extrusion is finished, so construct the object
//echo(extruded);
makeExtrudedPoly(extruded, merge=merge, trimEnds=trimEnds);
} else {
// generate points from rotating polygon
if(merge || (pos < (len(path) - 1))){
if((pos == 0) && (!merge)) {
newPts = myRotate(rToS(path[1] - path[0]),
points);
path_extrude(points=points, path=path, pos=pos+1,
merge=merge, trimEnds=trimEnds,
extruded=concat(extruded, [add(newPts,path[pos])]));
} else {
newPts = myRotate(rToS(path[(pos+1) % len(path)]
- path[(pos+len(path)-1) % len(path)]),
points);
path_extrude(points=points, path=path, pos=pos+1,
merge=merge, trimEnds=trimEnds,
extruded=concat(extruded, [add(newPts,path[pos])]));
}
} else {
newPts = myRotate(rToS(path[pos] - path[pos-1]),
points);
path_extrude(points=points, path=path, pos=pos+1,
merge=merge, trimEnds=trimEnds,
extruded=concat(extruded, [add(newPts,path[pos])]));
}
}
}
}

And then another recursive function to generate the polyhedron definition
using the point array. Because each polygon unit has the same number of
points at each position in the 3D path, I can define the joining
quadrilaterals (not necessarily planar) without too much effort:

module makeExtrudedPoly(ex, merge=false, trimEnds=false){
ps = flatten(ex);
pp = len(ex[1]); // points in one polygon
tp = len(ex[1]) * len(ex); // total number of points
if(!merge && !trimEnds){
polyhedron(points=ps, faces=concat(
[[for (i = [pp-1  : -1 :    0]) i]],
[[for (i = [tp-pp :  1 : tp-1]) i]],
[for (pt=[0:(len(ex)-2)])
for(i = [0:pp-1]) phFace(pp,tp,i,ptpp)],
[])
);
} else if(trimEnds) {
polyhedron(points=ps, faces=concat(
[[for (i = [pp2-1  : -1 :    pp]) i]],
[[for (i = [tp-pp2 :  1 : tp-pp-1]) i]],
[for (pt=[1:(len(ex)-3)])
for(i = [0:pp-1]) phFace(pp,tp,i,ptpp)]));
} else {
polyhedron(points=ps, faces=
[for (pt=[0:(len(ex)-1)])
for(i = [0:pp-1]) phFace(pp,tp,i,pt*pp)]);
}
}

Hopefully you can see that the majority of the code is spent dealing with
corner cases (i.e. what to do at the ends of the path), rather than the
bread and butter of the algorithm. The remainder of the code is made up from
helper functions to make the code a bit more succinct. OpenSCAD can do a lot
of this stuff natively, but only on actual objects (as far as I can tell)
and not on numerical matrices:

// rotation matrix implementation
// OpenSCAD seems to do this slightly different from Wikipedia
// c.f. https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations
function rot2Mat(rotVec, axis) =
(len(rotVec) == 2) ?
rot2Mat([rotVec[0], rotVec[1], 0], axis) :
(axis == "x") ?
[[1,              0,              0],
[0, cos(rotVec[0]),  sin(rotVec[0])],
[0, sin(rotVec[0]), -cos(rotVec[0])]] :
(axis == "y") ?
[[ cos(rotVec[1]), 0, sin(rotVec[1])],
[              0, 1,              0],
[-sin(rotVec[1]), 0, cos(rotVec[1])]] :
(axis == "z") ?
[[ cos(rotVec[2]), sin(rotVec[2]), 0],
[-sin(rotVec[2]), cos(rotVec[2]), 0],
[0,              0,              1]] : undef;

// convert point to 3D by setting Z to zero (if not present)
function c3D(tPoints) =
(len(tPoints[0]) < 3) ?
tPoints * [[1,0,0],[0,1,0]] :
tPoints;

// rotate [2D] points using a specificed XYZ rotation vector
function myRotate(rotation, points) =
c3D(points) * rot2Mat(rotation, "x")
* rot2Mat(rotation, "y")
* rot2Mat(rotation, "z");

// Determine spherical rotation for cartesian coordinates
function rToS(pt) =
[-acos((pt[2]) / norm(pt)),
0,
-atan2(pt[0],pt[1])];

// Generate a line between two points in 3D space [only used for debugging
this code]
module line3D(p1,p2){
translate((p1+p2)/2)
rotate(rToS(p1-p2))
cylinder(r=1, h=norm(p1-p2), center = true, $fn = 3);
}

// Flattens an array down one level (removing the enclosing array)
function flatten(pointArray, done=0, res=[]) =
(done == len(pointArray)) ?
res :
flatten(pointArray=pointArray, done=done+1,
res=concat(res,pointArray[done]));

// Creates a polyhedron face
function phFace(pp, tp, base, add=0) =
[base + add, (base+1) % pp + add,
(((base+1) % pp) + pp + add) % tp, (base + pp + add) % tp];

function add(vecArg, scArg, res=[]) =
(len(res) >= len(vecArg)) ?
res :
add(vecArg, scArg, res=concat(res,[vecArg[len(res)]+scArg]));

The code is a little slow, but I don't yet have any need to optimise it
further because it is sufficiently fast for the things I have been using it
for. See it in action here:

http://www.thingiverse.com/thing:186660

--
View this message in context: http://forum.openscad.org/Vertex-arrays-tp15876p15969.html
Sent from the OpenSCAD mailing list archive at Nabble.com.