On 1/7/2019 9:00 AM, PhilipJ wrote:

pts is an array of 3D points to connect.

The tersest answer to your question is

Line([[0,0,0],[30,30,30]]);

Reformatting a bit for readability:

Line([
[0,0,0],
[30,30,30]
]);

That will yield the default radius of 0.05 units.  You probably want
some other radius, so perhaps

Line([
[0,0,0],
[30,30,30]
], 5);

I'd recommend that you use positional arguments only in the most trivial
of cases, and that in more complex cases you use named arguments:

Line(r=5, pts=[
[0,0,0],
[30,30,30]
]);

The default for that module is to generate four-sided "cylinders".  You
can adjust that:

Line(r=5, fn=20, pts=[
[0,0,0],
[30,30,30]
]);

though I don't understand why there's an explicit fn parameter instead
of just using $fn.  I would remove the ", $fn=fn" from the cylinder call
at the end, and then any of these will work:

Line(r=5, $fn=20, pts=[
[0,0,0],
[30,30,30]
]);

$fn = 20;
Line(r=5, pts=[
[0,0,0],
[30,30,30]
]);

$fa = 10;
$fs = 0.1;
Line(r=5, pts=[
[0,0,0],
[30,30,30]
]);

I like that better because it integrates better with other OpenSCAD
constructs.

Similarly, I don't understand why there is an explicit color and
transparency options, rather than letting you control those using the
color() transformation.

Note that it's a list; you can connect multiple points, e.g.:

Line(r=5, pts=[
    [0,0,0],
    [30,30,30],
    [-30,30,30]
]);

Thanks, that is a great and comprehensive explanation, I appreciate it :-)

regards
PhilipJ

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

Jan 07, 2019; 5:08pm [image: PhilipJ]
http://forum.openscad.org/template/NamlServlet.jtp?macro=user_nodes&user=2371
PhilipJ
http://forum.openscad.org/template/NamlServlet.jtp?macro=user_nodes&user=2371

The long render times are not due to the hull but the union of the rods.
Better times result if the rods are just cylinders without the spherical
cap because the vertex count is smaller. The following code runs relatively
fast compared to the hull solution, however the rod joint is not as much
smooth.

$fn=30;

rod_dia=3;

rod([ 0, 0,0], [10,10,30], rod_dia);
rod([20, 0,0], [10,10,30], rod_dia);
rod([ 0,20,0], [10,10,30], rod_dia);
rod([20,20,0], [10,10,30], rod_dia);

module rod(p1,p2,d)
translate(p1)
rotFromTo([0,0,1], p2-p1)
cylinder(d=d, h=norm(p2-p1));

module rotFromTo(di,do)
if( norm(di-do)==0 || norm(di)==0 || norm(do)==0 )
children();
else
mirror(do/norm(do)+di/norm(di)) mirror(di) children();

The module rotFromTo does exactly what you were searching for: rotates the
cylinder from the upward direction ( [0,0,1] ) to the desired direction.

For another approach, take a look on

https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language#Rotation_rule_help

BTW, you may want to subscribe to the mailing list in order to have a
broader audience to your messages. Some people, like me, usually don't read
the forum messages in the forum site but rather from their mail box.

Si I have found the solution to my conversion problem, it was in the help
text under rotate (if only I'd read it properly!!).

All my attempts used atan2() for both angles, this uses acos for one of
them, I don't know what the difference is but this one works for all four
quadrant angles.

Thanks to everyone who took time to offer suggestions, now moving on to the
geodesic dome :-)
PhilipJ

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

Em ter, 8 de jan de 2019 às 22:05, runsun runsun@gmail.com escreveu:

runsun,

I disagree. The hull() operation (at least in this case of convex sets) is
very fast compared to the union of the rods. I have done some tests to show
it.

1. define the rods and the Phillip's tent frame as:

$fn=30;
translate([ 0, 0,0]) rotFromTo([0,0,1],-([ 0, 0,0] - [10,10,30]))
rod(rod_dia);
//translate([20, 0,0]) rotFromTo([0,0,1],-([20, 0,0] - [10,10,30]))
rod(rod_dia);
//translate([ 0,20,0]) rotFromTo([0,0,1],-([ 0,20,0] - [10,10,30]))
rod(rod_dia);
//translate([20,20,0]) rotFromTo([0,0,1],-([20,20,0] - [10,10,30]))
rod(rod_dia);

module rod(d)
hull() {
sphere(d/2);
translate([0,0,norm([ 0, 0,0] - [10,10,30])]) sphere(d/2);
}

Now, the rods are fixed length and vertical. Render this code with a clean
cache. The hulled rod will be in the cache. Render again dropping the
comments in the main code. The last running time will be spent just in the
union. In my computer, it is (surprisingly) greater then the render time of
the original code.

2. In the original code, instead of the hulled rods draw just a sphere at
   the top end. The render time will again show the union render time. In my
   computer, it is again (and very surprisingly) greater then the render time
   of the original code.

Conclusion: the render time of the hull() operation is negligible compared
to the union operation. Even the union of 4 disjoint sphere spends more
render time than the hull() of them.

Em qui, 10 de jan de 2019 às 00:15, runsun runsun@gmail.com escreveu:

I use my version of Line only in preview mode for debugging geometry. To
avoid any accidental render of lines, I check $preview inside of Line and
inhibit the drawing if false.