Is there a better way to do this?
Hello,
This design starts by rotating two or more overlapping circles around a
common center while extruding them upwards in the Z direction. The
resulting braided column is then duplicated around a larger diameter.
The outer diameter changes as a function of Z and the columns spiral
around that some number of degrees. Then the open center is filled with
a closed cylinder to make a solid.
The only way I can think of to change the diameter as a function of Z
and get the braided columns to spiral around is to create discrete
slices. The thinner the slices are the smoother the result. But I
always end up with something that takes many hours to generate an STL,
and contains a huge amount of geometry. Perhaps this is the only way to
achieve the result I want, but I would be interested in hearing about
alternative approaches, especially if they take less time. I usually
use a layer height (step) > 1.0 for testing, and no more than 0.2 for
the STL output.
Here's the code:
height=100; //height
ldiam=100; // large diameter
lrad=ldiam/2;
scols=20; // number of small columns
sdiam=8; // diameter of small circles
srad=sdiam/2;
sturns=3.0; // number of rotations of small circles
lturns=0.25; // number of turns for combined layers
covlp=0.20; // small circle overlap fraction
scircs=3; // number of small circles
step=1.2; // vertical layer interval
// calculated values
nstps=height/step; // total number of vertical steps
sdegr=360sturns; // number of degrees in sturns
ldegr=360lturns; // number of degrees in lturns
sdegrstp=sdegr/nstps; // number of degrees per step
ldegrstp=ldegr/nstps; // number of degrees per step
$fn=60;
// sine function values
ampl=20; // amplitude
ofs=lrad-ampl; // offset from 0
wl=height*2; // wavelength
shi=0; // shift in degrees
degr=150; // degree range
// calcualte size based on height
function siz(h)=(ofs+amplsin(degrh/height+shi));
// make the base 2d shape
module shape() {
for (c=[1:scircs]) {
rotate(360/scircsc)
translate([0,srad(1-covlp)])
circle(sdiam);
}
}
// make base shape 3d
module base_shape(h,s) {
// h = current height
// s = current step #, from 0
translate([0,0,h])
linear_extrude(height=step, twist=-sdegrstp)
rotate(s*sdegrstp)
shape();
}
module core(h,s) {
// h = vertical position
// s= scale factor
scale([s,s,1])
translate([0,0,h])
linear_extrude(height=step)
circle(d=ldiam);
}
module main(z,high) {
// z = starting position
// high = total height
translate([0,0,z])
for (p=[1:scols]) {
rotate(360/scols*p) {
//color("red") base();
for (h=[0:step:high]) {
s=siz(h)/lrad;
// adjust the profile shape
scale([s,s,1])
// twist as required
rotate(ldegrstp*h/step)
// shift to perimeter
translate([0,lrad,0])
// send height, step#
base_shape(h,h/step);
core(h,s);
}
}
}
}
main(0,height);
Regards,
Denver
It won't be fun, but you could construct each strand (of which I think
you have sixty) as a single polyhedron, then union them all. (Of
course, you only need one module that generates the polyhedron, and then
you call it with different parameters for where to start each strand in
a braided group, and generate the same braided group 20 times, rotated
each time.)
Pretty much, that means doing the same trigonometry that the various
rotates and translates would do, to generate the points, and then
connect them together appropriately.
You do want 60 distinct polyhedra, because you don't want to have to
figure out how to union them on your own.
You need to learn to write code, defining points in space rather than using
standard modules.
What you want is to create just 1 or 2 polyhedron strands and then
replicate them in some circular pattern.
On Sat, 13 Jul 2024 at 05:06, denverh via Discuss <
discuss@lists.openscad.org> wrote:
Hello,
This design starts by rotating two or more overlapping circles around a
common center while extruding them upwards in the Z direction. The
resulting braided column is then duplicated around a larger diameter.
The outer diameter changes as a function of Z and the columns spiral
around that some number of degrees. Then the open center is filled with
a closed cylinder to make a solid.
The only way I can think of to change the diameter as a function of Z
and get the braided columns to spiral around is to create discrete
slices. The thinner the slices are the smoother the result. But I
always end up with something that takes many hours to generate an STL,
and contains a huge amount of geometry. Perhaps this is the only way to
achieve the result I want, but I would be interested in hearing about
alternative approaches, especially if they take less time. I usually
use a layer height (step) > 1.0 for testing, and no more than 0.2 for
the STL output.
Here's the code:
height=100; //height
ldiam=100; // large diameter
lrad=ldiam/2;
scols=20; // number of small columns
sdiam=8; // diameter of small circles
srad=sdiam/2;
sturns=3.0; // number of rotations of small circles
lturns=0.25; // number of turns for combined layers
covlp=0.20; // small circle overlap fraction
scircs=3; // number of small circles
step=1.2; // vertical layer interval
// calculated values
nstps=height/step; // total number of vertical steps
sdegr=360sturns; // number of degrees in sturns
ldegr=360lturns; // number of degrees in lturns
sdegrstp=sdegr/nstps; // number of degrees per step
ldegrstp=ldegr/nstps; // number of degrees per step
$fn=60;
// sine function values
ampl=20; // amplitude
ofs=lrad-ampl; // offset from 0
wl=height*2; // wavelength
shi=0; // shift in degrees
degr=150; // degree range
// calcualte size based on height
function siz(h)=(ofs+amplsin(degrh/height+shi));
// make the base 2d shape
module shape() {
for (c=[1:scircs]) {
rotate(360/scircsc)
translate([0,srad(1-covlp)])
circle(sdiam);
}
}
// make base shape 3d
module base_shape(h,s) {
// h = current height
// s = current step #, from 0
translate([0,0,h])
linear_extrude(height=step, twist=-sdegrstp)
rotate(s*sdegrstp)
shape();
}
module core(h,s) {
// h = vertical position
// s= scale factor
scale([s,s,1])
translate([0,0,h])
linear_extrude(height=step)
circle(d=ldiam);
}
module main(z,high) {
// z = starting position
// high = total height
translate([0,0,z])
for (p=[1:scols]) {
rotate(360/scols*p) {
//color("red") base();
for (h=[0:step:high]) {
s=siz(h)/lrad;
// adjust the profile shape
scale([s,s,1])
// twist as required
rotate(ldegrstp*h/step)
// shift to perimeter
translate([0,lrad,0])
// send height, step#
base_shape(h,h/step);
core(h,s);
}
}
}
}
main(0,height);
Regards,
Denver
OpenSCAD mailing list
To unsubscribe send an email to discuss-leave@lists.openscad.org
Using BOSL2 you could do this pretty easily with sweep() I think or with
vnf_vertex_array() to make the object as a single polyhedron, perhaps.
On Fri, Jul 12, 2024 at 18:04 Sanjeev Prabhakar via Discuss <
discuss@lists.openscad.org> wrote:
You need to learn to write code, defining points in space rather than
using standard modules.
What you want is to create just 1 or 2 polyhedron strands and then
replicate them in some circular pattern.
On Sat, 13 Jul 2024 at 05:06, denverh via Discuss <
discuss@lists.openscad.org> wrote:
Hello,
This design starts by rotating two or more overlapping circles around a
common center while extruding them upwards in the Z direction. The
resulting braided column is then duplicated around a larger diameter.
The outer diameter changes as a function of Z and the columns spiral
around that some number of degrees. Then the open center is filled with
a closed cylinder to make a solid.
The only way I can think of to change the diameter as a function of Z
and get the braided columns to spiral around is to create discrete
slices. The thinner the slices are the smoother the result. But I
always end up with something that takes many hours to generate an STL,
and contains a huge amount of geometry. Perhaps this is the only way to
achieve the result I want, but I would be interested in hearing about
alternative approaches, especially if they take less time. I usually
use a layer height (step) > 1.0 for testing, and no more than 0.2 for
the STL output.
Here's the code:
height=100; //height
ldiam=100; // large diameter
lrad=ldiam/2;
scols=20; // number of small columns
sdiam=8; // diameter of small circles
srad=sdiam/2;
sturns=3.0; // number of rotations of small circles
lturns=0.25; // number of turns for combined layers
covlp=0.20; // small circle overlap fraction
scircs=3; // number of small circles
step=1.2; // vertical layer interval
// calculated values
nstps=height/step; // total number of vertical steps
sdegr=360sturns; // number of degrees in sturns
ldegr=360lturns; // number of degrees in lturns
sdegrstp=sdegr/nstps; // number of degrees per step
ldegrstp=ldegr/nstps; // number of degrees per step
$fn=60;
// sine function values
ampl=20; // amplitude
ofs=lrad-ampl; // offset from 0
wl=height*2; // wavelength
shi=0; // shift in degrees
degr=150; // degree range
// calcualte size based on height
function siz(h)=(ofs+amplsin(degrh/height+shi));
// make the base 2d shape
module shape() {
for (c=[1:scircs]) {
rotate(360/scircsc)
translate([0,srad(1-covlp)])
circle(sdiam);
}
}
// make base shape 3d
module base_shape(h,s) {
// h = current height
// s = current step #, from 0
translate([0,0,h])
linear_extrude(height=step, twist=-sdegrstp)
rotate(s*sdegrstp)
shape();
}
module core(h,s) {
// h = vertical position
// s= scale factor
scale([s,s,1])
translate([0,0,h])
linear_extrude(height=step)
circle(d=ldiam);
}
module main(z,high) {
// z = starting position
// high = total height
translate([0,0,z])
for (p=[1:scols]) {
rotate(360/scols*p) {
//color("red") base();
for (h=[0:step:high]) {
s=siz(h)/lrad;
// adjust the profile shape
scale([s,s,1])
// twist as required
rotate(ldegrstp*h/step)
// shift to perimeter
translate([0,lrad,0])
// send height, step#
base_shape(h,h/step);
core(h,s);
}
}
}
}
main(0,height);
Regards,
Denver
OpenSCAD mailing list
To unsubscribe send an email to discuss-leave@lists.openscad.org
OpenSCAD mailing list
To unsubscribe send an email to discuss-leave@lists.openscad.org
If you can break it down to slices of convex geometry (a single strand
having a circular cross section), then doing a hull of consecutive slices
works as a sort of sweep.
The linear extrude height is changed to some miniscule epsilon (to make a
technically 3d shape), and hull is done between two layers of the computed
shape.
height=100; //height
ldiam=100; // large diameter
lrad=ldiam/2;
scols=20; // number of small columns
sdiam=8; // diameter of small circles
srad=sdiam/2;
sturns=3.0; // number of rotations of small circles
lturns=0.25; // number of turns for combined layers
covlp=0.20; // small circle overlap fraction
scircs=3; // number of small circles
step=1.2; // vertical layer interval
// calculated values
nstps=height/step; // total number of vertical steps
sdegr=360sturns; // number of degrees in sturns
ldegr=360lturns; // number of degrees in lturns
sdegrstp=sdegr/nstps; // number of degrees per step
ldegrstp=ldegr/nstps; // number of degrees per step
$fn=60;
// sine function values
ampl=20; // amplitude
ofs=lrad-ampl; // offset from 0
wl=height*2; // wavelength
shi=0; // shift in degrees
degr=150; // degree range
// calcualte size based on height
function siz(h)=(ofs+amplsin(degrh/height+shi));
// make the base 2d shape
module shape(c) {
rotate(360/scircsc)
translate([0,srad(1-covlp)])
circle(sdiam);
}
// make base shape 3d
module base_shape(h,h2,s,s2,c) {
eps = 0.001;
// h = current height
// s = current step #, from 0
// c = circle index
hull() {
echo(h,h2,s,s2,c);
scale([s,s,1]) rotate(ldegrstp*h/step) translate([0,lrad,h])
linear_extrude(height=eps)
rotate(h/step*sdegrstp)
shape(c);
scale([s2,s2,1]) rotate(ldegrstp*h2/step) translate([0,lrad,h2-eps])
linear_extrude(height=eps)
rotate(h2/step*sdegrstp)
shape(c);
}
}
module core(h,s) {
// h = vertical position
// s= scale factor
scale([s,s,1])
translate([0,0,h])
linear_extrude(height=step)
circle(d=ldiam);
}
module main(z,high) {
// z = starting position
// high = total height
translate([0,0,z])
for (p=[1:scols]) {
rotate(360/scols*p) {
//color("red") base();
for(c=[1:scircs])
for(h=[0:step:high-step]) {
h2 = h+step;
s=siz(h)/lrad;
s2=siz(h2)/lrad;
// send height, step#
base_shape(h,h2,s,s2,c);
}
}
}
for(h=[0:step:high-step]) {
s=siz(h)/lrad;
core(h,s);
}
}
main(0,height);
On Fri, Jul 12, 2024 at 6:36 PM denverh via Discuss <
discuss@lists.openscad.org> wrote:
Hello,
This design starts by rotating two or more overlapping circles around a
common center while extruding them upwards in the Z direction. The
resulting braided column is then duplicated around a larger diameter.
The outer diameter changes as a function of Z and the columns spiral
around that some number of degrees. Then the open center is filled with
a closed cylinder to make a solid.
The only way I can think of to change the diameter as a function of Z
and get the braided columns to spiral around is to create discrete
slices. The thinner the slices are the smoother the result. But I
always end up with something that takes many hours to generate an STL,
and contains a huge amount of geometry. Perhaps this is the only way to
achieve the result I want, but I would be interested in hearing about
alternative approaches, especially if they take less time. I usually
use a layer height (step) > 1.0 for testing, and no more than 0.2 for
the STL output.
Here's the code:
height=100; //height
ldiam=100; // large diameter
lrad=ldiam/2;
scols=20; // number of small columns
sdiam=8; // diameter of small circles
srad=sdiam/2;
sturns=3.0; // number of rotations of small circles
lturns=0.25; // number of turns for combined layers
covlp=0.20; // small circle overlap fraction
scircs=3; // number of small circles
step=1.2; // vertical layer interval
// calculated values
nstps=height/step; // total number of vertical steps
sdegr=360sturns; // number of degrees in sturns
ldegr=360lturns; // number of degrees in lturns
sdegrstp=sdegr/nstps; // number of degrees per step
ldegrstp=ldegr/nstps; // number of degrees per step
$fn=60;
// sine function values
ampl=20; // amplitude
ofs=lrad-ampl; // offset from 0
wl=height*2; // wavelength
shi=0; // shift in degrees
degr=150; // degree range
// calcualte size based on height
function siz(h)=(ofs+amplsin(degrh/height+shi));
// make the base 2d shape
module shape() {
for (c=[1:scircs]) {
rotate(360/scircsc)
translate([0,srad(1-covlp)])
circle(sdiam);
}
}
// make base shape 3d
module base_shape(h,s) {
// h = current height
// s = current step #, from 0
translate([0,0,h])
linear_extrude(height=step, twist=-sdegrstp)
rotate(s*sdegrstp)
shape();
}
module core(h,s) {
// h = vertical position
// s= scale factor
scale([s,s,1])
translate([0,0,h])
linear_extrude(height=step)
circle(d=ldiam);
}
module main(z,high) {
// z = starting position
// high = total height
translate([0,0,z])
for (p=[1:scols]) {
rotate(360/scols*p) {
//color("red") base();
for (h=[0:step:high]) {
s=siz(h)/lrad;
// adjust the profile shape
scale([s,s,1])
// twist as required
rotate(ldegrstp*h/step)
// shift to perimeter
translate([0,lrad,0])
// send height, step#
base_shape(h,h/step);
core(h,s);
}
}
}
}
main(0,height);
Regards,
Denver
OpenSCAD mailing list
To unsubscribe send an email to discuss-leave@lists.openscad.org
Also the "core" was moved outside of the other loops so that it isn't
duplicated for every braid.
On Fri, Jul 12, 2024 at 11:00 PM Hans L thehans@gmail.com wrote:
If you can break it down to slices of convex geometry (a single strand
having a circular cross section), then doing a hull of consecutive slices
works as a sort of sweep.
The linear extrude height is changed to some miniscule epsilon (to make a
technically 3d shape), and hull is done between two layers of the computed
shape.
height=100; //height
ldiam=100; // large diameter
lrad=ldiam/2;
scols=20; // number of small columns
sdiam=8; // diameter of small circles
srad=sdiam/2;
sturns=3.0; // number of rotations of small circles
lturns=0.25; // number of turns for combined layers
covlp=0.20; // small circle overlap fraction
scircs=3; // number of small circles
step=1.2; // vertical layer interval
// calculated values
nstps=height/step; // total number of vertical steps
sdegr=360sturns; // number of degrees in sturns
ldegr=360lturns; // number of degrees in lturns
sdegrstp=sdegr/nstps; // number of degrees per step
ldegrstp=ldegr/nstps; // number of degrees per step
$fn=60;
// sine function values
ampl=20; // amplitude
ofs=lrad-ampl; // offset from 0
wl=height*2; // wavelength
shi=0; // shift in degrees
degr=150; // degree range
// calcualte size based on height
function siz(h)=(ofs+amplsin(degrh/height+shi));
// make the base 2d shape
module shape(c) {
rotate(360/scircsc)
translate([0,srad(1-covlp)])
circle(sdiam);
}
// make base shape 3d
module base_shape(h,h2,s,s2,c) {
eps = 0.001;
// h = current height
// s = current step #, from 0
// c = circle index
hull() {
echo(h,h2,s,s2,c);
scale([s,s,1]) rotate(ldegrstp*h/step) translate([0,lrad,h])
linear_extrude(height=eps)
rotate(h/step*sdegrstp)
shape(c);
scale([s2,s2,1]) rotate(ldegrstp*h2/step) translate([0,lrad,h2-eps])
linear_extrude(height=eps)
rotate(h2/step*sdegrstp)
shape(c);
}
}
module core(h,s) {
// h = vertical position
// s= scale factor
scale([s,s,1])
translate([0,0,h])
linear_extrude(height=step)
circle(d=ldiam);
}
module main(z,high) {
// z = starting position
// high = total height
translate([0,0,z])
for (p=[1:scols]) {
rotate(360/scols*p) {
//color("red") base();
for(c=[1:scircs])
for(h=[0:step:high-step]) {
h2 = h+step;
s=siz(h)/lrad;
s2=siz(h2)/lrad;
// send height, step#
base_shape(h,h2,s,s2,c);
}
}
}
for(h=[0:step:high-step]) {
s=siz(h)/lrad;
core(h,s);
}
}
main(0,height);
On Fri, Jul 12, 2024 at 6:36 PM denverh via Discuss <
discuss@lists.openscad.org> wrote:
Hello,
This design starts by rotating two or more overlapping circles around a
common center while extruding them upwards in the Z direction. The
resulting braided column is then duplicated around a larger diameter.
The outer diameter changes as a function of Z and the columns spiral
around that some number of degrees. Then the open center is filled with
a closed cylinder to make a solid.
The only way I can think of to change the diameter as a function of Z
and get the braided columns to spiral around is to create discrete
slices. The thinner the slices are the smoother the result. But I
always end up with something that takes many hours to generate an STL,
and contains a huge amount of geometry. Perhaps this is the only way to
achieve the result I want, but I would be interested in hearing about
alternative approaches, especially if they take less time. I usually
use a layer height (step) > 1.0 for testing, and no more than 0.2 for
the STL output.
Here's the code:
height=100; //height
ldiam=100; // large diameter
lrad=ldiam/2;
scols=20; // number of small columns
sdiam=8; // diameter of small circles
srad=sdiam/2;
sturns=3.0; // number of rotations of small circles
lturns=0.25; // number of turns for combined layers
covlp=0.20; // small circle overlap fraction
scircs=3; // number of small circles
step=1.2; // vertical layer interval
// calculated values
nstps=height/step; // total number of vertical steps
sdegr=360sturns; // number of degrees in sturns
ldegr=360lturns; // number of degrees in lturns
sdegrstp=sdegr/nstps; // number of degrees per step
ldegrstp=ldegr/nstps; // number of degrees per step
$fn=60;
// sine function values
ampl=20; // amplitude
ofs=lrad-ampl; // offset from 0
wl=height*2; // wavelength
shi=0; // shift in degrees
degr=150; // degree range
// calcualte size based on height
function siz(h)=(ofs+amplsin(degrh/height+shi));
// make the base 2d shape
module shape() {
for (c=[1:scircs]) {
rotate(360/scircsc)
translate([0,srad(1-covlp)])
circle(sdiam);
}
}
// make base shape 3d
module base_shape(h,s) {
// h = current height
// s = current step #, from 0
translate([0,0,h])
linear_extrude(height=step, twist=-sdegrstp)
rotate(s*sdegrstp)
shape();
}
module core(h,s) {
// h = vertical position
// s= scale factor
scale([s,s,1])
translate([0,0,h])
linear_extrude(height=step)
circle(d=ldiam);
}
module main(z,high) {
// z = starting position
// high = total height
translate([0,0,z])
for (p=[1:scols]) {
rotate(360/scols*p) {
//color("red") base();
for (h=[0:step:high]) {
s=siz(h)/lrad;
// adjust the profile shape
scale([s,s,1])
// twist as required
rotate(ldegrstp*h/step)
// shift to perimeter
translate([0,lrad,0])
// send height, step#
base_shape(h,h/step);
core(h,s);
}
}
}
}
main(0,height);
Regards,
Denver
OpenSCAD mailing list
To unsubscribe send an email to discuss-leave@lists.openscad.org
I tried with my python method:
just a rough attempt: scad file is 4 mb so not fit to share here, but it f6
renders in few seconds.
[image: Screenshot 2024-07-13 at 10.38.25 PM.png]
On Sat, 13 Jul 2024 at 05:06, denverh via Discuss <
discuss@lists.openscad.org> wrote:
Hello,
This design starts by rotating two or more overlapping circles around a
common center while extruding them upwards in the Z direction. The
resulting braided column is then duplicated around a larger diameter.
The outer diameter changes as a function of Z and the columns spiral
around that some number of degrees. Then the open center is filled with
a closed cylinder to make a solid.
The only way I can think of to change the diameter as a function of Z
and get the braided columns to spiral around is to create discrete
slices. The thinner the slices are the smoother the result. But I
always end up with something that takes many hours to generate an STL,
and contains a huge amount of geometry. Perhaps this is the only way to
achieve the result I want, but I would be interested in hearing about
alternative approaches, especially if they take less time. I usually
use a layer height (step) > 1.0 for testing, and no more than 0.2 for
the STL output.
Here's the code:
height=100; //height
ldiam=100; // large diameter
lrad=ldiam/2;
scols=20; // number of small columns
sdiam=8; // diameter of small circles
srad=sdiam/2;
sturns=3.0; // number of rotations of small circles
lturns=0.25; // number of turns for combined layers
covlp=0.20; // small circle overlap fraction
scircs=3; // number of small circles
step=1.2; // vertical layer interval
// calculated values
nstps=height/step; // total number of vertical steps
sdegr=360sturns; // number of degrees in sturns
ldegr=360lturns; // number of degrees in lturns
sdegrstp=sdegr/nstps; // number of degrees per step
ldegrstp=ldegr/nstps; // number of degrees per step
$fn=60;
// sine function values
ampl=20; // amplitude
ofs=lrad-ampl; // offset from 0
wl=height*2; // wavelength
shi=0; // shift in degrees
degr=150; // degree range
// calcualte size based on height
function siz(h)=(ofs+amplsin(degrh/height+shi));
// make the base 2d shape
module shape() {
for (c=[1:scircs]) {
rotate(360/scircsc)
translate([0,srad(1-covlp)])
circle(sdiam);
}
}
// make base shape 3d
module base_shape(h,s) {
// h = current height
// s = current step #, from 0
translate([0,0,h])
linear_extrude(height=step, twist=-sdegrstp)
rotate(s*sdegrstp)
shape();
}
module core(h,s) {
// h = vertical position
// s= scale factor
scale([s,s,1])
translate([0,0,h])
linear_extrude(height=step)
circle(d=ldiam);
}
module main(z,high) {
// z = starting position
// high = total height
translate([0,0,z])
for (p=[1:scols]) {
rotate(360/scols*p) {
//color("red") base();
for (h=[0:step:high]) {
s=siz(h)/lrad;
// adjust the profile shape
scale([s,s,1])
// twist as required
rotate(ldegrstp*h/step)
// shift to perimeter
translate([0,lrad,0])
// send height, step#
base_shape(h,h/step);
core(h,s);
}
}
}
}
main(0,height);
Regards,
Denver
OpenSCAD mailing list
To unsubscribe send an email to discuss-leave@lists.openscad.org
On 7/12/24 21:02, Hans L via Discuss wrote:
Also the "core" was moved outside of the other loops so that it isn't
duplicated for every braid.
On Fri, Jul 12, 2024 at 11:00 PM Hans L thehans@gmail.com wrote:
If you can break it down to slices of convex geometry (a single
strand having a circular cross section), then doing a hull of
consecutive slices works as a sort of sweep.
The linear extrude height is changed to some miniscule epsilon (to
make a technically 3d shape), and hull is done between two layers
of the computed shape.
Thanks, this works well. I began the project this way, but when I began
making the changes for scaling the outer diameter and spiraling the
braids around it, I somehow couldn't get past the idea that I had to
operate on the cross-section of the braid, rather than a strand. Since
the braid is partly concave, I couldn't use hull(), so I fell back on
thin slices. With the larger step size, this now takes 15 to 20 minutes
instead of 15 to 20 hours.
And thanks to everyone who responded with helpful suggestions. They're
all appreciated. Sanjeev's results are impressive indeed. I have read a
few articles about creating models that way, but it's a bit beyond my
current level of ability with OpenSCAD. Definitely something to keep in
mind for the future, though.
Thanks again everyone!
Denver
By the way, if you run a recent development snapshot from here:
https://openscad.org/downloads#snapshots
and enable "Manifold" in the experimental features preferences, then it
renders in about 1 second at the current detail level.
On Sat, Jul 13, 2024 at 5:28 PM denverh via Discuss <
discuss@lists.openscad.org> wrote:
On 7/12/24 21:02, Hans L via Discuss wrote:
Also the "core" was moved outside of the other loops so that it isn't
duplicated for every braid.
On Fri, Jul 12, 2024 at 11:00 PM Hans L thehans@gmail.com wrote:
If you can break it down to slices of convex geometry (a single strand
having a circular cross section), then doing a hull of consecutive slices
works as a sort of sweep.
The linear extrude height is changed to some miniscule epsilon (to make a
technically 3d shape), and hull is done between two layers of the computed
shape.
Thanks, this works well. I began the project this way, but when I began
making the changes for scaling the outer diameter and spiraling the braids
around it, I somehow couldn't get past the idea that I had to operate on
the cross-section of the braid, rather than a strand. Since the braid is
partly concave, I couldn't use hull(), so I fell back on thin slices. With
the larger step size, this now takes 15 to 20 minutes instead of 15 to 20
hours.
And thanks to everyone who responded with helpful suggestions. They're
all appreciated. Sanjeev's results are impressive indeed. I have read a
few articles about creating models that way, but it's a bit beyond my
current level of ability with OpenSCAD. Definitely something to keep in
mind for the future, though.
Thanks again everyone!
Denver
OpenSCAD mailing list
To unsubscribe send an email to discuss-leave@lists.openscad.org
On 7/13/24 16:19, Hans L via Discuss wrote:
By the way, if you run a recent development snapshot from here:
https://openscad.org/downloads#snapshots
and enable "Manifold" in the experimental features preferences, then
it renders in about 1 second at the current detail level.
I'll give that a try, thanks!
On Sat, Jul 13, 2024 at 5:28 PM denverh via Discuss
discuss@lists.openscad.org wrote:
On 7/12/24 21:02, Hans L via Discuss wrote:
Also the "core" was moved outside of the other loops so that it
isn't duplicated for every braid.
On Fri, Jul 12, 2024 at 11:00 PM Hans L <thehans@gmail.com> wrote:
If you can break it down to slices of convex geometry (a
single strand having a circular cross section), then doing a
hull of consecutive slices works as a sort of sweep.
The linear extrude height is changed to some miniscule
epsilon (to make a technically 3d shape), and hull is done
between two layers of the computed shape.
Thanks, this works well. I began the project this way, but when I
began making the changes for scaling the outer diameter and
spiraling the braids around it, I somehow couldn't get past the
idea that I had to operate on the cross-section of the braid,
rather than a strand. Since the braid is partly concave, I
couldn't use hull(), so I fell back on thin slices. With the
larger step size, this now takes 15 to 20 minutes instead of 15 to
20 hours.
And thanks to everyone who responded with helpful suggestions.
They're all appreciated. Sanjeev's results are impressive
indeed. I have read a few articles about creating models that
way, but it's a bit beyond my current level of ability with
OpenSCAD. Definitely something to keep in mind for the future,
though.
Thanks again everyone!
Denver
_______________________________________________
OpenSCAD mailing list
To unsubscribe send an email to discuss-leave@lists.openscad.org
OpenSCAD mailing list
To unsubscribe send an email todiscuss-leave@lists.openscad.org