Rhodonea (rose) curve generator using pipes

[johnsonm]

The rhodnoea / rose curve is a beautiful curve, but it is self-intersecting in its interesting manifestations, and this makes it tricky to model well. After several tries, I have something that uses Pipe by parts to model a 3D representation of it.

Some of the basic shapes are shown in this graphic from the Wikipedia article (n and d here are a and b in my model, respectively):

Here's the model:

// Inspired by Youness Alaoui <kakaroto@kakaroto.homelinux.net> customizable curve generator, but reimplemented with pipes

let a = Slider("a", 5, 1, 50, false, 1, 0);
let b = Slider("b", 7, 1, 50, false, 1, 0);
let points = Slider("points", 200, 50, 500, false, 10, 0);
let thickness = Slider("thickness", 3.2, 1, 10, false, 0.1, 1);
let draft = Slider("draft", 2.2, 0, 10, false, 0.1, 1);
let height = Slider("height", 19.1, 1, 50, false, 0.1, 1);
let radius = Slider("radius", 35, 10, 100, false, 1, 0);

function tan(x) {
    return Math.tan(x * (Math.PI / 180));
}
function sin(x) {
    return Math.sin(x * (Math.PI / 180));
}
function cos(x) {
    return Math.cos(x * (Math.PI / 180));
}
let sqrt = Math.sqrt;
let pow = Math.pow;

let iterations = 360 * b;
let epsilon = 0.0001;
let increment = iterations / points;
let top_thickness = thickness - (2 * (height * tan(draft)));
let k = a / b;

function X(i) {
    return cos(k * i) * sin (i);
}
function Y(i) {
    return cos(k * i) * cos (i);
}
function normx(y1, y2)  {
    return y1 - y2;
}
function normy(x1, x2) {
    return x2 - x1;
}
function norm(x, y) {
    return sqrt(pow(x, 2) + pow(y, 2));
}
function nx(x, normx, norm, w) {
    return x + (normx / norm * w);
}
function ny(y, normy, norm, w) {
    return y + (normy / norm * w);
}
function distance(x1, y1, x2, y2) {
    return sqrt(pow(x2-x1, 2) + pow(y2-y1, 2));
}

let guide = [];
let segments = [0];
let w = thickness / 2;
let top_w = top_thickness / 2;
let orig_px0 = 0;
let orig_py0 = 0;
let orig_nx0 = 0;
let orig_ny0 = 0;

for (let i = 0, j = 0; i < iterations; i += increment, j++) { // stop eventually; the break may apply earlier
    let x0 = X(i) * radius;
    let y0 = Y(i) * radius;
    let dist0 = distance(0, 0, x0, y0);
    let i2 = i + increment;
    let x1 = X(i2) * radius;
    let y1 = Y(i2) * radius;
    let dist1 = distance(0, 0, x1, y1);
    let normx0 = normx(y0, y1);
    let normy0 = normy(x0, x1);
    let norm0 = norm(normx0, normy0);
    let px0 = nx(x0, normx0, norm0, w);
    let py0 = ny(y0, normy0, norm0, w);
    let nx0 = nx(x0, normx0, norm0, -w);
    let ny0 = ny(y0, normy0, norm0, -w);
    let addFace = false;
    let face = [];
    if (guide.length === 0) {
        orig_px0 = px0;
        orig_py0 = py0;
        orig_nx0 = nx0;
        orig_ny0 = ny0;
        addFace = true;
    } else {
        if ((distance(orig_px0, orig_py0, px0, py0) < epsilon) && (distance(orig_nx0, orig_ny0, nx0, ny0) < epsilon)) {
            // this section is considered to be the same as the initial section; don't add more
            break;
        }
        if ((dist0 > guide[j-1][0] && dist0 > dist1) || (dist0 < guide[j-1][0] && dist0 < dist1)) {
            // local minimum or maximum
            segments.push(j);
            addFace = true;
        }
    }
    if (addFace) {
        // define Polygon for Pipe
        let pzx0 = nx(x0, normx0, norm0, top_w);
        let pzy0 = ny(y0, normy0, norm0, top_w);
        let nzx0 = nx(x0, normx0, norm0, -top_w);
        let nzy0 = ny(y0, normy0, norm0, -top_w);
        face = [
            [nx0, ny0, 0],
            [px0, py0, 0],
            [pzx0, pzy0, height],
            [nzx0, nzy0, height],
        ];
    }
    // this face is actually used only if this is chosen as a first segment point
    guide.push([dist0, [x0, y0, 0], face]);
}

// close the final loop
guide.push(guide[0]);
segments.push(guide.length-1);
console.log(segments);

for (let i=0; i < segments.length - 1; i++) {
    let segment = [];
    for (let j=segments[i]; j<=segments[i+1]; j++) {
        segment.push(guide[j][1]);
    }
    let crossSection = Polygon(guide[segments[i]][2])
    Pipe(crossSection, BSpline(segment, false));
}

Because I have a specific use case that requires angled sides, my code allows you to set a draft angle; this allows the top surface to be a different thickness from the bottom surface. If this angle is 0° the pipe will have a rectangular cross-section. Draft angle is useful for molding. So whether you are 3D printing a part to burn out for investment casting, or making a mold for green sand casting, or (as I am) making an aluminum "iron" for cooking rosettes, or making a mold for casting plastic, you need some angle on the sides to get the part out of or off the mold.

The radius parameter is the minimal radius of a cylinder centered at the origin and enclosing the center line of the part. Therefore, the part will have an effective radius of the specified radius plus half the specified thickness.

I have a roughly equivalent model in OpenSCAD that is an actual derivative of kakaroto's work, but that model is done by many smaller iterations as polyhedra because b-splines are not exposed in OpenSCAD. Additionally, OpenSCAD frequently fails to produce a manifold and requires repair in meshlab, whereas this CascadeStudio model has produced a manifold each time I have checked so far.

Many thanks to @zalo pointing me away from Loft to use Pipe instead, and for other debugging help while I worked on this.

[Irev-Dev]

Those are really nice curves, I'll have to keep those in the back of my mind for applications. the only thing that's coming to mind is to take a quarter of one and make a book stop out of it 🤷

[johnsonm]

Bookends could be beautiful with some of them for sure!

Cut only partway through your stock, or glue to backing, and they could make beautiful trivets and coasters.

Also christmas tree ornaments, where laser cutting or 3d printing can get the inside corners sharper.

At a larger scale, muntins or mullions for round windows?

There's a start.

But for now I'll stick to the rosette iron project.

[johnsonm]

I updated the link and code above to fix a bug in applying the draft angle.

[johnsonm]

The rosette iron project was a bit of a saga when it came to cutting it out of actual aluminum, but I finally made it:

https://forum.makerforums.info/t/mathematical-rosette-iron/82599

[Irev-Dev]

Draft angle is useful for molding.

So you didn't end up casting I take it?

[johnsonm]

I added the draft angle was because it is, itself, a mold. It is dipped partway into raw batter which sticks to the mold, and then it is immersed in hot oil that cooks the batter. The draft angle on the sides helps the cooked shell release from the mold after it is removed from the hot oil. I set the draft angle on this to mimic the normal rosette irons I already had.

My original intent was to machine it. In my frustration with OpenSCAD not producing a manifold, but prusa-slicer auto-repairing the non-manifold, I did briefly consider learning to cast it by burning out a 3D print in investment plaster (whence it would be removed by fracturing the plaster, so draft angle wouldn't matter), but I am not equipped for that at this time. I did learn to heal non-manifold meshes in meshlab so that I could process it with Kiri:Moto, but that made experimentation a lot of work. CascadeStudio producing a proper manifold made experimentation more pleasant. Also, this model renders very quickly in CascadeStudio, whereas the corresponding model in OpenSCAD (implemented with many polyhedra since OpenSCAD doesn't expose splines) takes a substantial time to render.

[Irev-Dev]

I linked to this from this reddit post

[johnsonm]

Thanks! Sadly there's something brittle here and I didn't see the results I hoped from trying it out. Oh well.