def segs2poly()

in src/python/phyre/virtual_tools.py [0:0]

• 63 lines of code
• 20 McCabe index (conditional complexity)

def segs2poly(seglist, r):
    vlist = [np.array(v) for v in seglist]
    # Start by figuring out the initial edge (ensure ccw winding)
    iseg = vlist[1] - vlist[0]
    ipt = vlist[0]
    iang = np.arctan2(iseg[1], iseg[0])
    if iang <= (-np.pi / 4.) and iang >= (-np.pi * 3. / 4.):
        # Going downwards
        prev1 = (ipt[0] - r, ipt[1])
        prev2 = (ipt[0] + r, ipt[1])
    elif iang >= (np.pi / 4.) and iang <= (np.pi * 3. / 4.):
        # Going upwards
        prev1 = (ipt[0] + r, ipt[1])
        prev2 = (ipt[0] - r, ipt[1])
    elif iang >= (-np.pi / 4.) and iang <= (np.pi / 4.):
        # Going rightwards
        prev1 = (ipt[0], ipt[1] - r)
        prev2 = (ipt[0], ipt[1] + r)
    else:
        # Going leftwards
        prev1 = (ipt[0], ipt[1] + r)
        prev2 = (ipt[0], ipt[1] - r)

    polylist = []
    for i in range(1, len(vlist) - 1):
        pi = vlist[i]
        pim = vlist[i - 1]
        pip = vlist[i + 1]
        sm = pim - pi
        sp = pip - pi
        # Get the angle of intersection between two lines
        angm = np.arctan2(sm[1], sm[0])  #.angle
        angp = np.arctan2(sp[1], sp[0])  #.angle
        angi = (angm - angp) % (2 * np.pi)
        # Find the midpoint of this angle and turn it back into a unit vector
        angn = (angp + (angi / 2.)) % (2 * np.pi)
        if angn < 0:
            angn += 2 * np.pi
        #unitn = np.array([1.0, 0.0])#pm.Vec2d.unit()
        unitn = np.array([np.cos(angn), np.sin(angn)])
        #unitn.angle = angn
        xdiff = r if unitn[0] >= 0 else -r
        ydiff = r if unitn[1] >= 0 else -r
        next3 = (pi[0] + xdiff, pi[1] + ydiff)
        next4 = (pi[0] - xdiff, pi[1] - ydiff)
        # Ensure appropriate winding -- next3 should be on the left of next4
        if _isleft(prev2, next3, next4):
            tmp = next4
            next4 = next3
            next3 = tmp
        curr_poly = [prev1, prev2, next3, next4]
        curr_poly.reverse()
        polylist.append(curr_poly)
        prev1 = next4
        prev2 = next3

    # Finish by figuring out the final edge
    fseg = vlist[-2] - vlist[-1]
    fpt = vlist[-1]
    fang = np.arctan2(fseg[1], fseg[0])  #.angle
    if fang <= (-np.pi / 4.) and fang >= (-np.pi * 3. / 4.):
        # Coming from downwards
        next3 = (fpt[0] - r, fpt[1])
        next4 = (fpt[0] + r, fpt[1])
    elif fang >= (np.pi / 4.) and fang <= (np.pi * 3. / 4.):
        # Coming from upwards
        next3 = (fpt[0] + r, fpt[1])
        next4 = (fpt[0] - r, fpt[1])
    elif fang >= (-np.pi / 4.) and fang <= (np.pi / 4.):
        # Coming from rightwards
        next3 = (fpt[0], fpt[1] - r)
        next4 = (fpt[0], fpt[1] + r)
    else:
        # Coming from leftwards
        next3 = (fpt[0], fpt[1] + r)
        next4 = (fpt[0], fpt[1] - r)
    curr_poly = [prev1, prev2, next3, next4]
    curr_poly.reverse()
    polylist.append(curr_poly)
    return polylist