Ideas for converting shapes to shapely (instead of drawing them)

[villares]

There is a built-in function for getting the points from bezier_curve() (the standalone version of the shape you can build with bezier_vertex()). There is no such method for a quadratic bezier curves... but getting the points from a curve based on `quadratic_vertex()) was not very hard.

import py5
from shapely import Polygon
from villares.shapely_helpers import draw_shapely # github.com/villares/villares

def setup():
    py5.size(600, 600)

def draw():
    py5.background(200)
    outer = star_points(300, 300, 100, 250, 12)
    inner = star_points(300, 300, 250, 100, 12, rot=py5.PI / 12)
    # in order to make a polygon with holes using Polygon(outer, holes[inner])
    # you have to be sure of the "winding" clockwise/counter-clockwise,
    # so you might prefer Polygon(outer).difference(Polygon(inner))
    star = Polygon(outer, [reversed(inner)])
    py5.stroke(0)
    draw_shapely(star)
    py5.stroke(200, 0, 0)
    py5.points(outer + inner)

def quadratic_points(ax, ay, bx, by, cx, cy, num_points=None, first_point=False):
    if num_points is None:
        num_points = int(py5.dist(ax, ay, bx, by) + py5.dist(bx, by, cx, cy)) // int(5 + 1/(1 + py5.dist(ax, ay, cx, cy)))
    if num_points <= 2:
        return [(ax, ay), (cx, cy)] if first_point else [(cx, cy)]
    pts = []
    for t_num in range(0 if first_point else 1, num_points + 1):
        t = t_num / num_points
        x = (1 - t) * (1 - t) * ax + 2 * (1 - t) * t * bx + t * t * cx
        y = (1 - t) * (1 - t) * ay + 2 * (1 - t) * t * by + t * t * cy
        pts.append((x, y))
    return pts
           
def star_points(x, y, radius_a, radius_b, n_points, rot=0):
    if n_points < 3:
        raise TypeError("Number of points sould be at least 3.")
    pts = []
    step = py5.TWO_PI / n_points
    for i in range(n_points + 1):
        ang = i * step + rot
        sx = py5.cos(ang) * radius_a
        sy = py5.sin(ang) * radius_a
        cx = py5.cos(ang + step / 2.) * radius_b
        cy = py5.sin(ang + step / 2.) * radius_b
        if i == 0:
            pts.append((x + cx, y + cy))
        else:
            pts.extend(quadratic_points(anchor_x, anchor_y, x + sx, y + sy, x + cx, y + cy))
        anchor_x, anchor_y = x + cx, y + cy
    return pts
    
py5.run_sketch()

I think I'll mostly use shapely.Polygon to get some of my shapes into shapely, but I wonder if I should add some circle() and ellipse() helpers (maybe using point buffers and affinity transforms for the ellipses).

def shapely_circle(x, y, d):
     return Point(x, y).buffer(d / 2)

def shapely_ellipse(x, y, w, h):
    return shapely.affinity.scale(circle(x, y, max(w, h)), w, h)
    # maybe add shapely.affinity.rotate(ellipse, angle), check angle start/orientation

Rotations and transformations are in a different style, and another idea would be to tap into `matplotlib.patches' https://matplotlib.org/stable/api/patches_api.html ...

[hx2A]

Does the Python library bezier help you at all? Although what you are doing is more educational because the math behind bezier curves is more apparent.

I don't think trying to use py5 to do the bezier curve calculations to be extracted and put into shapely is the most efficient way to go. py5's bezier curve methods aren't really designed for that.

What you are exploring here might be a useful py5 library extension idea for working with py5 + shapely.

[villares]

Good idea! I should have a look at the library, but even with little effort I might be able to numpy-vectorize and avoid the loops!

(Calling the Java dependent bezier_points() a lot for the the other bezier curves might be terribly slow indeed)

[villares]

😄

def quadratic_points(ax, ay, bx, by, cx, cy, num_points=None, first_point=False):
    if num_points is None:
        num_points = int(py5.dist(ax, ay, bx, by) + py5.dist(bx, by, cx, cy) + py5.dist(ax, ay, cx, cy)) // 10
    if num_points <= 2:
        return [(ax, ay), (cx, cy)] if first_point else [(cx, cy)]
    t = np.arange(0 if first_point else 1, num_points + 1) / num_points
    x = (1 - t) * (1 - t) * ax + 2 * (1 - t) * t * bx + t * t * cx
    y = (1 - t) * (1 - t) * ay + 2 * (1 - t) * t * by + t * t * cy
    return np.column_stack((x, y))

def bezier_points(ax, ay, bx, by, cx, cy, dx, dy, num_points=24, first_point=False):
    t = np.arange(0 if first_point else 1, num_points + 1) / num_points
    x = (1 - t) ** 3 * ax + 3 * (1 - t) ** 2 * t * bx + 3 * (1 - t) * t * t * cx + t ** 3 * dx
    y = (1 - t) ** 3 * ay + 3 * (1 - t) ** 2 * t * by + 3 * (1 - t) * t * t * cy + t ** 3 * dy
    return np.column_stack((x, y))

[hx2A]

Looking good! Effective use of numpy there.