Bezier patch cut?

[wohali]

Hi there, I'm trying to take a cube and cut it via a bezier patch, so that the top surface is a curve I've defined as follows:

    patch = [
        [[0, 0, 20],  [5, 0, 20]],
        [[0, 10, 5], [5, 10, 5]],
        [[0, 40, 0],  [5, 40, 0]]     
    ];
    vnf_top = bezier_vnf(patch, splinesteps=32);

What's the simplest way to do this? I couldn't work out how to fake it using this patch as a top surface, and connected patches on the other 5 sides to make the rest of the solid. Nor could I work out how to take the bezier patch and pass it to heightfield().

Both seem like they'd theoretically work, I just can't make the mental jump from point A to B. Can anyone assist?

[AUnicyclingProgrammer]

How are you wanting to cut the cube? The patch you've provided is just a curved strip. This shape reminds me of the teardrop rounding. Would applying that to a cuboid get close enough?

[wohali]

No, a teardrop won't do it, and in this case the curve isn't fully tweaked yet. This simplified example is consistent across the X axis, but the eventual surface won't be. However the 'cube' is roughly a 5 x 40 cross-section, with most of the curve along the 40 (y) length.

Basically I want a cube where the top surface is a bezier patch.

[AUnicyclingProgrammer]

I should preface this by saying, I haven't actually tried using the beziers library or vnfs yet, but they are perfect for a project I have in mind so I've been studying the wiki. I might get a few details wrong here or there.

I can think of two ways to do this (assuming that all the edges of the cuboid are straight and perpendicular to each other).

1. Use a second vnf surface or combination of surfaces to close the shape, then difference it from the top. (Assuming all the edges of the patch will be flush with the edges of the cuboid a simple square)

2. Build the 5 other faces of the cube, and use the bezier patch to close the top. You may have to reverse the face directions, but I'm not sure.

If the top edge isn't perfectly straight, you could create closed 2D path with the outline you want, using bezpath_curve() to convert the bezier path into a normal path you can concatenate to the end of a standard path in such a way that it closes the shape. Then, you can convert said closed 2d path into a region and convert that to a VNF, if I'm understanding the wiki correctly.

However, if this shape will have the same cross-section extruded along one axis, it would probably be easier to construct the region mentioned above and extrude it. Personally, I like using extrude_from_to() to create -oids (cuboids, prismoids, and other extruded 2d shapes), but there are many options.

Like I mentioned above, I haven't actually used these features before, so these are my best guesses. If nothing else I hope this gives you a few ideas for how to approach this.

[wohali]

Thanks for the advice!

The top edge isn't straight along the important faces, or I would have done step 1 already. 😞

The "close the path with the curve" bit I need to do for step 2 is where I'm getting stuck. I am not sure, with a patch, how to extract the exact spline from all four edges of the patch, and then use those splines as vertices for a face that I can then use to construct a polygon.

[AUnicyclingProgrammer]

I got to wondering if bezier patches are simply a net of bezier curves, so I decided to test out that theory (partially, just on the edges). This theory appears to be correct, as if you extract the control points form the edges of the patch and use them to construct bezier curves, they line up exactly. (It takes a bit of filtering though).

Here's some code I quickly threw together to test that. I'm sure it could be improved a lot, but it was sufficient to test my theory. The patch is just a modified example from the beziers wiki page.

Edit: I'm putting the code in a collapsible markdown section so it doesn't take up so much space.

Expand Code

up(0) { // So the code can be collapsed
    patch = [
        [[-50, 50,  0], [-16, 50,  20], [ 16, 50,  20], [50, 50,  10]],
        [[-50, 16, 20], [-16, 16,  40], [ 16, 16,  40], [50, 16, 20]],
        [[-50,-16, 20], [-16,-16,  40], [ 16,-16,  40], [50,-16, 30]],
        [[-50,-50,  -10], [-16,-50,  20], [ 16,-50,  30], [50,-50, 20]]
    ];
    debug_bezier_patches(patches=[patch], size=1, showcps=true);
    pts = bezier_patch_points(patch, [0:0.2:1], [0:0.2:1]);
    for (row=pts) move_copies(row) color("magenta") sphere(d=3, $fn=12);

    ExtractAndPlotEdgeCurve(patch, BACK);
    ExtractAndPlotEdgeCurve(patch, RIGHT);
    ExtractAndPlotEdgeCurve(patch, FRONT);
    ExtractAndPlotEdgeCurve(patch, LEFT);
}

module ExtractAndPlotEdgeCurve(patch, edge, offset = 5) {
    patchDimensions = list_shape(patch);
    patchBounds = pointlist_bounds(flatten(patch));

    extractedEdgeCurve = ExtractPatchEdge(patch, edge);

    edgeToTranslationLookupStruct = struct_set([],
                        [BACK, [0, patchBounds[1].y + offset, 0],
                        FRONT, [0, patchBounds[0].y - offset, 0],
                        LEFT, [patchBounds[0].x - offset, 0, 0],
                        RIGHT, [patchBounds[1].x + offset, 0, 0]
                        ]);
    translationAmount = struct_val(edgeToTranslationLookupStruct, edge);
    
    edgeToRotationLookupStruct = struct_set([],
                        [BACK, [90, 0, 0],
                        FRONT, [90, 0, 0],
                        LEFT, [90, 0, 90],
                        RIGHT, [90, 0, 90]
                        ]);
    rotationAmount = struct_val(edgeToRotationLookupStruct, edge);
    
    move(translationAmount)
    rot(rotationAmount)
    debug_bezier(bezpath = extractedEdgeCurve);
}

function ExtractPatchEdge(patch, edge) =
    let(
        patchDimensions = list_shape(patch),
        
        edgeRowColumnLookupStruct = struct_set([],
                        [BACK, [0, undef],
                        FRONT, [patchDimensions[0]-1, undef],
                        LEFT, [undef, 0],
                        RIGHT, [undef, patchDimensions[1]-1]
                        ]),
        rowColumnIndex = struct_val(edgeRowColumnLookupStruct, edge),
        
        edgeToRelevantCoordinateIndiciesLookupStruct = struct_set([],
                        [BACK, [1, 0, 1],
                        FRONT, [1, 0, 1],
                        LEFT, [0, 1, 1],
                        RIGHT, [0, 1, 1]
                        ]),
        relevantCoordinateIndicies = struct_val(edgeToRelevantCoordinateIndiciesLookupStruct, edge),

        rowIndex = rowColumnIndex[0],
        columnIndex = rowColumnIndex[1],

        patchEdge3DBezPoints = is_def(rowIndex)
            ? ExtractRow(patch, rowIndex)
            : ExtractColumn(patch, columnIndex),

        patchEdgeBezPoints = ExtractElementIndicies(patchEdge3DBezPoints, relevantCoordinateIndicies)
    ) patchEdgeBezPoints;
//

function ExtractRow(grid, rowIndex) =
    let(
        gridDimensions = list_shape(grid),
        extractedRow = [
            for(j = [0:gridDimensions[1]-1])
                grid[rowIndex][j]
        ]
    ) extractedRow;
//

function ExtractColumn(grid, columnIndex) =
    let(
        gridDimensions = list_shape(grid),
        extractedColumn = [
            for(i = [0:gridDimensions[0]-1])
                grid[i][columnIndex]
        ]
    ) extractedColumn;
//

function ExtractElementIndicies(list, indicies) =
    [for (pt = list) bselect(pt, indicies)];
//

I hope this helps, it was just the excuse I needed to begin tinkering with beziers.