'This function actually creates the wind barbs.  *u* and *v*
are components of the vector in the *x* and *y* directions,
respectively.
*nflags*, *nbarbs*, and *half_barb*, empty_flag* are,
*respectively, the number of flags, number of barbs, flag for
*half a barb, and flag for empty barb, ostensibly obtained
*from :meth:`_find_tails`.
*length* is the length of the barb staff in points.
*pivot* specifies the point on the barb around which the
entire barb should be rotated.  Right now, valid options are
\'tip\' and \'middle\'. Can also be a number, which shifts the start
of the barb that many points from the origin.
*sizes* is a dictionary of coefficients specifying the ratio
of a given feature to the length of the barb. These features
include:
- *spacing*: space between features (flags, full/half
barbs)
- *height*: distance from shaft of top of a flag or full
barb
- *width* - width of a flag, twice the width of a full barb
- *emptybarb* - radius of the circle used for low
magnitudes
*fill_empty* specifies whether the circle representing an
empty barb should be filled or not (this changes the drawing
of the polygon).
*flip* is a flag indicating whether the features should be flipped to
the other side of the barb (useful for winds in the southern
hemisphere).
This function returns list of arrays of vertices, defining a polygon
for each of the wind barbs.  These polygons have been rotated to
properly align with the vector direction.'

def _make_barbs(self, u, v, nflags, nbarbs, half_barb, empty_flag, length, pivot, sizes, fill_empty, flip):

    spacing = (length * sizes.get(u'spacing', 0.125))
    full_height = (length * sizes.get(u'height', 0.4))
    full_width = (length * sizes.get(u'width', 0.25))
    empty_rad = (length * sizes.get(u'emptybarb', 0.15))
    pivot_points = dict(tip=0.0, middle=((- length) / 2.0))
    if flip:
        full_height = (- full_height)
    endx = 0.0
    try:
        endy = float(pivot)
    except ValueError:
        endy = pivot_points[pivot.lower()]
    angles = (- (ma.arctan2(v, u) + (np.pi / 2)))
    circ = CirclePolygon((0, 0), radius=empty_rad).get_verts()
    if fill_empty:
        empty_barb = circ
    else:
        empty_barb = np.concatenate((circ, circ[::(-1)]))
    barb_list = []
    for (index, angle) in np.ndenumerate(angles):
        if empty_flag[index]:
            barb_list.append(empty_barb)
            continue
        poly_verts = [(endx, endy)]
        offset = length
        for i in range(nflags[index]):
            if (offset != length):
                offset += (spacing / 2.0)
            poly_verts.extend([[endx, (endy + offset)], [(endx + full_height), ((endy - (full_width / 2)) + offset)], [endx, ((endy - full_width) + offset)]])
            offset -= (full_width + spacing)
        for i in range(nbarbs[index]):
            poly_verts.extend([(endx, (endy + offset)), ((endx + full_height), ((endy + offset) + (full_width / 2))), (endx, (endy + offset))])
            offset -= spacing
        if half_barb[index]:
            if (offset == length):
                poly_verts.append((endx, (endy + offset)))
                offset -= (1.5 * spacing)
            poly_verts.extend([(endx, (endy + offset)), ((endx + (full_height / 2)), ((endy + offset) + (full_width / 4))), (endx, (endy + offset))])
        poly_verts = transforms.Affine2D().rotate((- angle)).transform(poly_verts)
        barb_list.append(poly_verts)
    return barb_list
