Ejemplo n.º 1
0
def polyarc(arcs, color = 'b', linewidth=1, alpha=1,
            capstyle='butt', joinstyle='miter'):
    """ """

    for arc in arcs:
        if abs(arc.d) < 1e-5:
            verts = [(arc.p0.x,arc.p0.y), (arc.p1.x,arc.p1.y)]
            codes = [Path.MOVETO, Path.LINETO]
            path = Path(verts, codes)
            arc = patches.PathPatch(path,
                                    linewidth = linewidth,
                                    edgecolor = color,
                                    facecolor = 'None',
                                    alpha     = alpha)
        else:
            center,radius, angle0, angle1, negative = arc.to_conventional()
            angle0 = 180*angle0/math.pi
            angle1 = 180*angle1/math.pi
            if negative:
                angle0, angle1 = angle1, angle0
            arc = Arc(center, 2*radius, 2*radius, 0, angle0, angle1,
                      color=color, linewidth = linewidth, alpha=alpha)
        arc.set_path_effects([PathEffects.Stroke(capstyle=capstyle,
                                                 joinstyle=joinstyle )])
        plt.gca().add_artist(arc)
    plt.xticks([])
    plt.yticks([])
Ejemplo n.º 2
0
 def _path_to_parent(self, node):
     c = self.n2c[node]; theta1 = c.angle; r = c.depth
     M = Path.MOVETO; L = Path.LINETO
     pc = self.n2c[node.parent]; theta2 = pc.angle
     px1 = math.cos(math.radians(c.angle))*pc.depth
     py1 = math.sin(math.radians(c.angle))*pc.depth
     verts = [(c.x,c.y),(px1,py1)]; codes = [M,L]
     t1, t2 = tuple(sorted((theta1,theta2)))
     diam = pc.depth*2
     arc = Arc((0,0), diam, diam, theta1=t1, theta2=t2)
     arcpath = arc.get_path()
     av = arcpath.vertices * pc.depth
     ac = arcpath.codes
     verts.extend(av.tolist())
     codes.extend(ac.tolist())
     return verts, codes
Ejemplo n.º 3
0
from matplotlib.patches import Wedge, Arc
import matplotlib.pyplot as plt
#вставить необходимые операторы
n = 6  # размер области

m = 5  # размер области

plt.xlim(0, n)

plt.ylim(0, m)

ax = plt.gca()
# нарисовать сектор
figure_w = Wedge(
    (3, 1), 2, 45, 135
)  # сформировать сектор, параметры для цвета линии и заливки, а также толщины линии не указывать
ax.add_patch(figure_w)

# нарисовать дугу
# дуга должна иметь определенную толщину (linewidth = 3), нулевой угол поворота, цвет не указывать
figure_a = Arc((3, 1), 6, 6, 0, 45, 135, lw=3)  # сформировать дугу
ax.add_patch(figure_a)

plt.show()
Ejemplo n.º 4
0
def _arc(i, j, width=1, linestyle='-', color='black'):
	"""
	Creating a single arc from i to j
	"""
	return Arc(((i+j)/2., 0.4), abs(i-j), abs(i-j), 0, 0, 180, linewidth=width,
		edgecolor=color, fill=False, linestyle=linestyle)
Ejemplo n.º 5
0
def draw_field(line_dist,
               center_dist,
               players=[],
               balls=[],
               ball_colors=[],
               ball_sizes=[],
               title=''):
    if balls and not ball_colors:
        ball_colors = ['green'] * len(balls)
    if balls and not ball_sizes:
        ball_sizes = [2] * len(balls)
    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    arc_center = (line_dist**2 - center_dist**2) / (line_dist * sqrt(2) -
                                                    2 * center_dist)
    radius = center_dist - arc_center
    theta = arcsin(line_dist * sqrt(2) / (2 * radius)) * 180 / pi
    if line_dist > center_dist:
        theta = -theta
    height = center_dist - line_dist / sqrt(2)
    max_dist = max(line_dist, center_dist)
    plt.plot([0, line_dist / sqrt(2)], [0, line_dist / sqrt(2)], color="black")
    plt.plot([0, -line_dist / sqrt(2)], [0, line_dist / sqrt(2)],
             color="black")
    plt.plot([-line_dist / sqrt(2), line_dist / sqrt(2)],
             [max_dist + 10, max_dist + 10],
             color="white")
    base_size = 3
    #first base
    plt.plot([90 / sqrt(2), 90 / sqrt(2) - base_size],
             [90 / sqrt(2), 90 / sqrt(2) + base_size],
             color='black')
    plt.plot([90 / sqrt(2), 90 / sqrt(2) - base_size],
             [90 / sqrt(2) + base_size * 2, 90 / sqrt(2) + base_size],
             color='black')
    plt.plot([90 / sqrt(2), 90 / sqrt(2) + base_size],
             [90 / sqrt(2) + base_size * 2, 90 / sqrt(2) + base_size],
             color='black')
    #second base
    plt.plot([0, -base_size], [90 * sqrt(2), 90 * sqrt(2) + base_size],
             color='black')
    plt.plot([0, -base_size],
             [90 * sqrt(2) + base_size * 2, 90 * sqrt(2) + base_size],
             color='black')
    plt.plot([0, base_size],
             [90 * sqrt(2) + base_size * 2, 90 * sqrt(2) + base_size],
             color='black')
    plt.plot([0, base_size], [90 * sqrt(2), 90 * sqrt(2) + base_size],
             color='black')
    #third base
    plt.plot([-90 / sqrt(2), -(90 / sqrt(2) - base_size)],
             [90 / sqrt(2), 90 / sqrt(2) + base_size],
             color='black')
    plt.plot([-90 / sqrt(2), -(90 / sqrt(2) - base_size)],
             [90 / sqrt(2) + base_size * 2, 90 / sqrt(2) + base_size],
             color='black')
    plt.plot([-90 / sqrt(2), -(90 / sqrt(2) + base_size)],
             [90 / sqrt(2) + base_size * 2, 90 / sqrt(2) + base_size],
             color='black')

    fence = Arc((0, arc_center),
                height=2 * radius,
                width=2 * radius,
                angle=0,
                theta1=90 - theta,
                theta2=90 + theta,
                color="black")
    ax.add_patch(fence)
    infield = Arc((0, 0),
                  height=320,
                  width=150 * sqrt(2),
                  angle=0,
                  theta1=45,
                  theta2=135,
                  color="black")
    ax.add_patch(infield)
    mound = plt.Circle((0, 60.6), 10, color='black', fill=False)
    ax.add_patch(mound)
    for player in players:
        pos = plt.Circle(player, 5, color='blue')
        ax.add_patch(pos)
    for ball, color, size in zip(balls, ball_colors, ball_sizes):
        pos = plt.Circle(ball, size, color=color)
        ax.add_patch(pos)
    plt.title(title)
    plt.show()
Ejemplo n.º 6
0
def circos_plot(interaction_space,
                sender_cells,
                receiver_cells,
                ligands,
                receptors,
                excluded_score=0,
                metadata=None,
                sample_col='#SampleID',
                group_col='Groups',
                meta_cmap='Set2',
                cells_cmap='Pastel1',
                colors=None,
                ax=None,
                figsize=(10, 10),
                fontsize=14,
                legend=True,
                ligand_label_color='dimgray',
                receptor_label_color='dimgray',
                filename=None):
    '''Generates the circos plot in the exact order that sender and
    receiver cells are provided. Similarly, ligands and receptors are
    sorted by the order they are input.

    Parameters
    ----------
    interaction_space : cell2cell.core.interaction_space.InteractionSpace
        Interaction space that contains all a distance matrix after running the
        the method compute_pairwise_communication_scores. Alternatively, this
        object can a SingleCellInteractions or a BulkInteractions object after
        running the method compute_pairwise_communication_scores.

    sender_cells : list
        List of cells to be included as senders.

    receiver_cells : list
        List of cells to be included as receivers.

    ligands : list
        List of genes/proteins to be included as ligands produced by the
        sender cells.

    receptors : list
        List of genes/proteins to be included as receptors produced by the
        receiver cells.

    excluded_score : float, default=0
        Rows that have a communication score equal or lower to this will
        be dropped from the network.

    metadata : pandas.Dataframe, default=None
        Metadata associated with the cells, cell types or samples in the
        matrix containing CCC scores. If None, cells will be color only by
        individual cells.

    sample_col : str, default='#SampleID'
        Column in the metadata for the cells, cell types or samples
        in the matrix containing CCC scores.

    group_col : str, default='Groups'
        Column in the metadata containing the major groups of cells, cell types
        or samples in the matrix with CCC scores.

    meta_cmap : str, default='Set2'
        Name of the matplotlib color palette for coloring the major groups
        of cells.

    cells_cmap : str, default='Pastel1'
        Name of the color palette for coloring individual cells.

    colors : dict, default=None
        Dictionary containing tuples in the RGBA format for indicating colors
        of major groups of cells. If colors is specified, meta_cmap will be
        ignored.

    ax : matplotlib.axes.Axes, default=None
        Axes instance for a plot.

    figsize : tuple, default=(10, 10)
        Size of the figure (width*height), each in inches.

    fontsize : int, default=14
        Font size for ligand and receptor labels.

    legend : boolean, default=True
        Whether including legends for cell and cell group colors as well
        as ligand/receptor colors.

    ligand_label_color : str, default='dimgray'
        Name of the matplotlib color palette for coloring the labels of
        ligands.

    receptor_label_color : str, default='dimgray'
        Name of the matplotlib color palette for coloring the labels of
        receptors.

    filename : str, default=None
        Path to save the figure of the elbow analysis. If None, the figure is not
        saved.

    Returns
    -------
    ax : matplotlib.axes.Axes
        Axes instance containing a circos plot.
    '''
    if hasattr(interaction_space, 'interaction_elements'):
        if 'communication_matrix' not in interaction_space.interaction_elements.keys(
        ):
            raise ValueError(
                'Run the method compute_pairwise_communication_scores() before generating circos plots.'
            )
        else:
            readable_ccc = get_readable_ccc_matrix(
                interaction_space.interaction_elements['communication_matrix'])
    elif hasattr(interaction_space, 'interaction_space'):
        if 'communication_matrix' not in interaction_space.interaction_space.interaction_elements.keys(
        ):
            raise ValueError(
                'Run the method compute_pairwise_communication_scores() before generating circos plots.'
            )
        else:
            readable_ccc = get_readable_ccc_matrix(
                interaction_space.interaction_space.
                interaction_elements['communication_matrix'])
    else:
        raise ValueError('Not a valid interaction_space')

    # Figure setups
    if ax is None:
        R = 1.0
        center = (0, 0)

        fig = plt.figure(figsize=figsize, frameon=False)
        ax = fig.add_axes([0., 0., 1., 1.], aspect='equal')
        ax.set_axis_off()
        ax.set_xlim((-R * 1.05 + center[0]), (R * 1.05 + center[0]))
        ax.set_ylim((-R * 1.05 + center[1]), (R * 1.05 + center[1]))
    else:
        xlim = ax.get_xlim()
        ylim = ax.get_ylim()
        x_range = abs(xlim[1] - xlim[0])
        y_range = abs(ylim[1] - ylim[0])

        R = np.nanmin([x_range / 2.0, y_range / 2.0]) / 1.05
        center = (np.nanmean(xlim), np.nanmean(ylim))

    # Elements to build network
    # TODO: Add option to select sort_by: None (as input), cells, proteins or metadata
    sorted_nodes = sort_nodes(sender_cells=sender_cells,
                              receiver_cells=receiver_cells,
                              ligands=ligands,
                              receptors=receptors)

    # Build network
    G = _build_network(sender_cells=sender_cells,
                       receiver_cells=receiver_cells,
                       ligands=ligands,
                       receptors=receptors,
                       sorted_nodes=sorted_nodes,
                       readable_ccc=readable_ccc,
                       excluded_score=excluded_score)

    # Get coordinates
    nodes_dict = get_arc_angles(G=G, sorting_feature='sorting')

    edges_dict = dict()
    for k, v in nodes_dict.items():
        edges_dict[k] = get_cartesian(theta=np.nanmean(v),
                                      radius=0.95 * R / 2.,
                                      center=center,
                                      angle='degrees')

    small_R = determine_small_radius(edges_dict)

    # Colors
    cells = list(set(sender_cells + receiver_cells))
    if metadata is not None:
        meta = metadata.set_index(sample_col).reindex(cells)
        meta = meta[[group_col]].fillna('NA')
        labels = meta[group_col].unique().tolist()
        if colors is None:
            colors = get_colors_from_labels(labels, cmap=meta_cmap)
        meta['Color'] = [colors[idx] for idx in meta[group_col]]
    else:
        meta = pd.DataFrame(index=cells)
    # Colors for cells, not major groups
    colors = get_colors_from_labels(cells, cmap=cells_cmap)
    meta['Cells-Color'] = [colors[idx] for idx in meta.index]
    # signal_colors = {'ligand' : 'brown', 'receptor' : 'black'}
    signal_colors = {
        'ligand': ligand_label_color,
        'receptor': receptor_label_color
    }

    # Draw edges
    # TODO: Automatically determine lw given the size of the arcs (each ligand or receptor)
    lw = 10
    for l, r in G.edges:
        path = Path([edges_dict[l], center, edges_dict[r]],
                    [Path.MOVETO, Path.CURVE3, Path.CURVE3])

        patch = patches.FancyArrowPatch(
            path=path,
            arrowstyle="->,head_length={},head_width={}".format(
                lw / 3.0, lw / 3.0),
            lw=lw / 2.,
            edgecolor='gray',  #meta.at[l.split('^')[0], 'Cells-Color'],
            zorder=1,
            facecolor='none',
            alpha=0.15)
        ax.add_patch(patch)

    # Draw nodes
    # TODO: Automatically determine lw given the size of the figure
    cell_legend = dict()
    if metadata is not None:
        meta_legend = dict()
    else:
        meta_legend = None
    for k, v in nodes_dict.items():
        diff = 0.05 * abs(
            v[1] -
            v[0])  # Distance to substract and avoid nodes touching each others

        cell = k.split('^')[0]
        cell_color = meta.at[cell, 'Cells-Color']
        cell_legend[cell] = cell_color
        ax.add_patch(
            Arc(center,
                R,
                R,
                theta1=diff + v[0],
                theta2=v[1] - diff,
                edgecolor=cell_color,
                lw=lw))
        coeff = 1.0
        if metadata is not None:
            coeff = 1.1

            meta_color = meta.at[cell, 'Color']
            ax.add_patch(
                Arc(center,
                    coeff * R,
                    coeff * R,
                    theta1=diff + v[0],
                    theta2=v[1] - diff,
                    edgecolor=meta_color,
                    lw=10))

            meta_legend[meta.at[cell, group_col]] = meta_color

        label_coord = get_cartesian(theta=np.nanmean(v),
                                    radius=coeff * R / 2. +
                                    min([small_R * 3, coeff * R * 0.05]),
                                    center=center,
                                    angle='degrees')

        # Add Labels
        v2 = label_coord
        x = v2[0]
        y = v2[1]
        rotation = np.nanmean(v)

        if x >= 0:
            ha = 'left'
        else:
            ha = 'right'
        va = 'center'

        if (rotation <= 90):
            rotation = abs(rotation)
        elif (rotation <= 180):
            rotation = -abs(rotation - 180)
        elif (rotation <= 270):
            rotation = abs(rotation - 180)
        else:
            rotation = abs(rotation)

        ax.text(x,
                y,
                k.split('^')[1],
                rotation=rotation,
                rotation_mode="anchor",
                horizontalalignment=ha,
                verticalalignment=va,
                color=signal_colors[G.nodes[k]['signal']],
                fontsize=fontsize)

    # Draw legend
    if legend:
        generate_circos_legend(cell_legend=cell_legend,
                               meta_legend=meta_legend,
                               signal_legend=signal_colors,
                               fontsize=fontsize)

    if filename is not None:
        plt.savefig(filename, dpi=300, bbox_inches='tight')
    return ax
Ejemplo n.º 7
0
import matplotlib.pyplot as plt
from matplotlib.patches import Arc

m = [0, -0.5]
n = [-0.5, 0]

R = 1.0
x, y = 0.0, 0.0
a, b = R, R

fig_width, fig_height = 1, 1
fig = plt.figure(figsize=(fig_width, fig_height), frameon=False)
ax = fig.add_axes([0.0, 0.0, 1.0, 1.0], aspect='equal')
ax.set_xlim(-R, R)
ax.set_ylim(-R, R)

ax.axhline(0.0)
ax.axvline(0.0)

print("give the theta1")
z = float(input())
ax.add_patch(Arc((x, y), a, b, theta1=0.0, theta2=360.0, edgecolor='w'))
print("give the theta2")
p = float(input())
q = z
r = p
ax.add_patch(Arc((x, y), a, b, theta1=q, theta2=r, edgecolor='b', lw=1.5))
plt.plot(x, y, m, n)
plt.show()
Ejemplo n.º 8
0
def draw_ball_field(color='#20458C', lw=2):
    """
    绘制篮球场
    """
    # 新建一个大小为(6,6)的绘图窗口
    plt.figure(figsize=(6, 6))
    # 获得当前的Axes对象ax,进行绘图
    ax = plt.gca()

    # 对篮球场进行底色填充
    lines_outer_rec = Rectangle(xy=(-250, -47.5),
                                width=500,
                                height=470,
                                linewidth=lw,
                                color='#F0F0F0',
                                fill=True)
    # 设置篮球场填充图层为最底层
    lines_outer_rec.set_zorder(0)
    # 将rec添加进ax
    ax.add_patch(lines_outer_rec)

    # 绘制篮筐,半径为7.5
    circle_ball = Circle(xy=(0, 0),
                         radius=7.5,
                         linewidth=lw,
                         color=color,
                         fill=False)
    # 将circle添加进ax
    ax.add_patch(circle_ball)

    # 绘制篮板,尺寸为(60,1)
    plate = Rectangle(xy=(-30, -7.5),
                      width=60,
                      height=-1,
                      linewidth=lw,
                      color=color,
                      fill=False)
    # 将rec添加进ax
    ax.add_patch(plate)

    # 绘制2分区的外框线,尺寸为(160,190)
    outer_rec = Rectangle(xy=(-80, -47.5),
                          width=160,
                          height=190,
                          linewidth=lw,
                          color=color,
                          fill=False)
    # 将rec添加进ax
    ax.add_patch(outer_rec)

    # 绘制2分区的内框线,尺寸为(120,190)
    inner_rec = Rectangle(xy=(-60, -47.5),
                          width=120,
                          height=190,
                          linewidth=lw,
                          color=color,
                          fill=False)
    # 将rec添加进ax
    ax.add_patch(inner_rec)

    # 绘制罚球区域圆圈,半径为60
    circle_punish = Circle(xy=(0, 142.5),
                           radius=60,
                           linewidth=lw,
                           color=color,
                           fill=False)
    # 将circle添加进ax
    ax.add_patch(circle_punish)

    # 绘制三分线的左边线
    three_left_rec = Rectangle(xy=(-220, -47.5),
                               width=0,
                               height=140,
                               linewidth=lw,
                               color=color,
                               fill=False)
    # 将rec添加进ax
    ax.add_patch(three_left_rec)

    # 绘制三分线的右边线
    three_right_rec = Rectangle(xy=(220, -47.5),
                                width=0,
                                height=140,
                                linewidth=lw,
                                color=color,
                                fill=False)
    # 将rec添加进ax
    ax.add_patch(three_right_rec)

    # 绘制三分线的圆弧,圆心为(0,0),半径为238.66,起始角度为22.8,结束角度为157.2
    three_arc = Arc(xy=(0, 0),
                    width=477.32,
                    height=477.32,
                    theta1=22.8,
                    theta2=157.2,
                    linewidth=lw,
                    color=color,
                    fill=False)
    # 将arc添加进ax
    ax.add_patch(three_arc)

    # 绘制中场处的外半圆,半径为60
    center_outer_arc = Arc(xy=(0, 422.5),
                           width=120,
                           height=120,
                           theta1=180,
                           theta2=0,
                           linewidth=lw,
                           color=color,
                           fill=False)
    # 将arc添加进ax
    ax.add_patch(center_outer_arc)

    # 绘制中场处的内半圆,半径为20
    center_inner_arc = Arc(xy=(0, 422.5),
                           width=40,
                           height=40,
                           theta1=180,
                           theta2=0,
                           linewidth=lw,
                           color=color,
                           fill=False)
    # 将arc添加进ax
    ax.add_patch(center_inner_arc)

    # 绘制篮球场外框线,尺寸为(500,470)
    lines_outer_rec = Rectangle(xy=(-250, -47.5),
                                width=500,
                                height=470,
                                linewidth=lw,
                                color=color,
                                fill=False)
    # 将rec添加进ax
    ax.add_patch(lines_outer_rec)

    return ax
Ejemplo n.º 9
0
    arrowprops=dict(arrowstyle='->, head_length=0.8, head_width=0.5'))
plt.text(xhat - 0.17, yhat + 0.21, r'$F(u)$', fontsize=fsize)
plt.plot(xhat, yc + 0.06, 'ko', ms=8.0, mfc='w')
plt.text(xhat + 0.05,
         yc + 0.05,
         '$\it{unconstrained}\,\, \it{minimizer}$',
         fontsize=12.0)
ax = plt.gca()
for r in [0.4, 0.5, 0.6, 0.7]:
    alpha = (180.0 / np.pi) * np.arcsin(0.3 / r)
    beta = 90.0 + (180.0 / np.pi) * np.arcsin(0.25 / r)
    beta = min(beta, 180.0 - alpha)
    arc = Arc((xhat, yc),
              2.0 * r,
              2.0 * r,
              angle=0.0,
              theta1=alpha,
              theta2=beta,
              color='k',
              lw=0.75)
    ax.add_patch(arc)
plt.text(-0.2, 0.7, r'$\mathcal{H}$', fontsize=fsize)
plt.text(0.9, 0.6, r'$\mathcal{K}_\varphi$', fontsize=fsize)
plt.axis('tight')
plt.axis('off')
plt.axis('equal')
writeout('cartoonplane.pdf')

# inner cone approx figure
plt.figure(figsize=(8, 6))
xm, ym = 0.6, 0.4
makeaxes(-0.4, xm, -0.25, ym)
Ejemplo n.º 10
0
def draw_court(ax=None, color='gray', lw=1, outer_lines=False):
    """
    Returns an axes with a basketball court drawn onto to it.
    Function taken from tutorial by Savvas Tjortjoglou 

    This function draws a court based on the x and y-axis values that the NBA
    stats API provides for the shot chart data.  For example, the NBA stat API
    represents the center of the hoop at the (0,0) coordinate.  Twenty-two feet
    from the left of the center of the hoop in is represented by the (-220,0)
    coordinates.  So one foot equals +/-10 units on the x and y-axis.

    TODO: explain the parameters
    """
    if ax is None:
        ax = plt.gca()

    # Create the various parts of an NBA basketball court

    # Create the basketball hoop
    hoop = Circle((0, 0), radius=7.5, linewidth=lw, color=color, fill=False)

    # Create backboard
    backboard = Rectangle((-30, -7.5), 60, -1, linewidth=lw, color=color)

    # The paint
    # Create the outer box 0f the paint, width=16ft, height=19ft
    outer_box = Rectangle((-80, -47.5),
                          160,
                          190,
                          linewidth=lw,
                          color=color,
                          fill=False)
    # Create the inner box of the paint, widt=12ft, height=19ft
    inner_box = Rectangle((-60, -47.5),
                          120,
                          190,
                          linewidth=lw,
                          color=color,
                          fill=False)

    # Create free throw top arc
    top_free_throw = Arc((0, 142.5),
                         120,
                         120,
                         theta1=0,
                         theta2=180,
                         linewidth=lw,
                         color=color,
                         fill=False)
    # Create free throw bottom arc
    bottom_free_throw = Arc((0, 142.5),
                            120,
                            120,
                            theta1=180,
                            theta2=0,
                            linewidth=lw,
                            color=color,
                            linestyle='dashed')
    # Restricted Zone, it is an arc with 4ft radius from center of the hoop
    restricted = Arc((0, 0),
                     80,
                     80,
                     theta1=0,
                     theta2=180,
                     linewidth=lw,
                     color=color)

    # Three point line
    # Create the right side 3pt lines, it's 14ft long before it arcs
    corner_three_a = Rectangle((-220, -47.5),
                               0,
                               140,
                               linewidth=lw,
                               color=color)
    # Create the right side 3pt lines, it's 14ft long before it arcs
    corner_three_b = Rectangle((220, -47.5), 0, 140, linewidth=lw, color=color)
    # 3pt arc - center of arc will be the hoop, arc is 23'9" away from hoop
    three_arc = Arc((0, 0),
                    475,
                    475,
                    theta1=22,
                    theta2=158,
                    linewidth=lw,
                    color=color)

    # Center Court
    center_outer_arc = Arc((0, 422.5),
                           120,
                           120,
                           theta1=180,
                           theta2=0,
                           linewidth=lw,
                           color=color)
    center_inner_arc = Arc((0, 422.5),
                           40,
                           40,
                           theta1=180,
                           theta2=0,
                           linewidth=lw,
                           color=color)

    # List of the court elements to be plotted onto the axes
    court_elements = [
        hoop, backboard, outer_box, inner_box, top_free_throw,
        bottom_free_throw, restricted, corner_three_a, corner_three_b,
        three_arc, center_outer_arc, center_inner_arc
    ]

    if outer_lines:
        # Draw the half court line, baseline and side out bound lines
        outer_lines = Rectangle((-250, -47.5),
                                500,
                                470,
                                linewidth=lw,
                                color=color,
                                fill=False)
        court_elements.append(outer_lines)

    # Add the court elements onto the axes
    for element in court_elements:
        ax.add_patch(element)

    return ax
Ejemplo n.º 11
0
def draw_court(ax=None, color='black', outer_lines=False):
    outer_lw = 4
    inner_lw = 4
    # If an axes object isn't provided to plot onto, just get current one
    if ax is None:
        ax = plt.gca()

    # Create the various parts of an NBA basketball court

    # Create the basketball hoop
    # Diameter of a hoop is 18" so it has a radius of 9", which is a value
    # 7.5 in our coordinate system
    hoop = Circle((0, 0),
                  radius=7.5,
                  linewidth=inner_lw,
                  color=color,
                  fill=False,
                  zorder=25)

    # Create backboard
    backboard = Rectangle((-30, -7.5),
                          60,
                          -1,
                          linewidth=inner_lw,
                          color=color,
                          zorder=0)

    # The paint
    # Create the outer box 0f the paint, width=16ft, height=19ft
    left_paint = Rectangle((-80, -47.5),
                           0,
                           190,
                           linewidth=inner_lw,
                           color=color,
                           fill=False,
                           zorder=0)
    # Create the outer box 0f the paint, width=16ft, height=19ft
    right_paint = Rectangle((80, 142.5),
                            0,
                            -190,
                            linewidth=inner_lw,
                            color=color,
                            fill=False,
                            zorder=0)
    # Create the outer box 0f the paint, width=16ft, height=19ft
    free_throw_line = Rectangle((-80, 142.5),
                                160,
                                0,
                                linewidth=inner_lw,
                                color=color,
                                fill=False,
                                zorder=0)

    # Create free throw top arc
    top_free_throw = Arc((0, 142.5),
                         120,
                         120,
                         theta1=0,
                         theta2=180,
                         linewidth=inner_lw,
                         color=color,
                         fill=False,
                         zorder=0)

    # Restricted Zone, it is an arc with 4ft radius from center of the hoop
    restricted = Arc((0, 0),
                     80,
                     80,
                     theta1=0,
                     theta2=180,
                     linewidth=inner_lw,
                     color=color,
                     zorder=0)

    # Three point line
    # Create the side 3pt lines, they are 14ft long before they begin to arc
    corner_three_a = Rectangle((-220, -47.5),
                               0,
                               140,
                               linewidth=inner_lw,
                               color=color,
                               zorder=0)
    corner_three_b = Rectangle((220, -47.5),
                               0,
                               140,
                               linewidth=inner_lw,
                               color=color)
    # 3pt arc - center of arc will be the hoop, arc is 23'9" away from hoop
    # I just played around with the theta values until they lined up with the
    # threes
    three_arc = Arc((0, 0),
                    475,
                    475,
                    theta1=22,
                    theta2=158,
                    linewidth=inner_lw,
                    color=color,
                    zorder=0)

    # List of the court elements to be plotted onto the axes
    court_elements = [
        hoop, backboard, left_paint, right_paint, free_throw_line,
        top_free_throw, corner_three_a, corner_three_b, three_arc, restricted
    ]

    if outer_lines:
        # Draw the half court line, baseline and side out bound lines
        outer_lines = Rectangle((-250, -47.5),
                                500,
                                470,
                                linewidth=outer_lw,
                                color=color,
                                fill=False,
                                zorder=0)
        court_elements.append(outer_lines)

    # Add the court elements onto the axes
    for element in court_elements:
        ax.add_patch(element)

    return ax
Ejemplo n.º 12
0
# give it a big marker
ax1.plot([x], [y],
         marker='x',
         linestyle='None',
         mfc='red',
         mec='red',
         markersize=10)

##################################################
# make the axes
ax = subplot(312, aspect='equal', sharex=ax1, sharey=ax1)
ax.set_aspect('equal', 'datalim')

# make the lower-bound arc
diam = (r - delta) * 2.0
lower_arc = Arc((0.0, 0.0), diam, diam, 0.0, fill=False, edgecolor="darkgreen")
ax.add_patch(lower_arc)

# make the target arc
diam = r * 2.0
target_arc = Arc((0.0, 0.0), diam, diam, 0.0, fill=False, edgecolor="darkred")
ax.add_patch(target_arc)

# make the upper-bound arc
diam = (r + delta) * 2.0
upper_arc = Arc((0.0, 0.0), diam, diam, 0.0, fill=False, edgecolor="darkblue")
ax.add_patch(upper_arc)

# make the target
diam = delta * 2.0
target = Arc((x, y), diam, diam, 0.0, fill=False, edgecolor="#DD1208")
Ejemplo n.º 13
0
    def draw(self, ax, showframe=False):
        """ Draw the element
            ax        : matplotlib axis
            showframe : Draw the axis frame. Useful for debugging.
        """
        for path in self.paths:
            ax.plot(path[:, 0],
                    path[:, 1],
                    color=self.color,
                    lw=self.lw,
                    solid_capstyle='round',
                    ls=self.ls)

        for s in self.shapes:
            if s.get('shape') == 'circle':
                xy = np.array(s.get('center', [0, 0]))
                xy = self.translate(xy - self.ofst)
                rad = s.get('radius', 1) * self.z
                fill = s.get('fill', False)
                fillcolor = s.get('fillcolor', self.color)
                circ = plt.Circle(xy=xy,
                                  radius=rad,
                                  ec=self.color,
                                  fc=fillcolor,
                                  fill=fill,
                                  zorder=3,
                                  lw=self.lw)
                ax.add_patch(circ)
            elif s.get('shape') == 'poly':
                xy = np.array(s.get('xy', [[0, 0]]))
                xy = self.translate(xy - self.ofst)
                closed = s.get('closed', True)
                fill = s.get('fill', False)
                fillcolor = s.get('fillcolor', self.color)
                poly = plt.Polygon(xy=xy,
                                   closed=closed,
                                   ec=self.color,
                                   fc=fillcolor,
                                   fill=fill,
                                   zorder=3,
                                   lw=self.lw)
                ax.add_patch(poly)
            elif s.get('shape') == 'arc':
                xy = np.array(s.get('center', [0, 0]))
                xy = self.translate(xy - self.ofst)

                w = s.get('width', 1) * self.z
                h = s.get('height', 1) * self.z
                th1 = s.get('theta1', 35)
                th2 = s.get('theta2', -35)
                if self.reverse: th1, th2 = th2, th1

                angle = s.get('angle', self.theta)
                arc = Arc(xy,
                          width=w,
                          height=h,
                          theta1=th1,
                          theta2=th2,
                          angle=angle,
                          color=self.color,
                          lw=self.lw)
                ax.add_patch(arc)

                # Add an arrowhead to the arc
                arrow = s.get('arrow', None)  # 'cw' or 'ccw' or None
                if arrow is not None:
                    if arrow == 'ccw':
                        dx = np.cos(np.deg2rad(th2 + 90)) / 100
                        dy = np.sin(np.deg2rad(th2 + 90)) / 100
                        s = [
                            xy[0] + w / 2 * np.cos(np.deg2rad(th2)),
                            xy[1] + h / 2 * np.sin(np.deg2rad(th2))
                        ]
                    else:
                        dx = -np.cos(np.deg2rad(th1 + 90)) / 100
                        dy = -np.sin(np.deg2rad(th1 + 90)) / 100

                        s = [
                            xy[0] + w / 2 * np.cos(np.deg2rad(th1)),
                            xy[1] + h / 2 * np.sin(np.deg2rad(th1))
                        ]

                    # Rotate the arrow head
                    co = np.cos(np.radians(angle))
                    so = np.sin(np.radians(angle))
                    m = np.array([[co, so], [-so, co]])
                    s = np.dot(s - xy, m) + xy
                    darrow = np.dot([dx, dy], m)

                    ax.arrow(s[0],
                             s[1],
                             darrow[0],
                             darrow[1],
                             head_width=.15,
                             head_length=.25,
                             color=self.color)

            elif s.get('shape') == 'arrow':
                start = np.array(s.get('start', [0, 0]))
                end = np.array(s.get('end', [1, 0]))
                start = self.translate(start - self.ofst)
                end = self.translate(end - self.ofst)
                hw = s.get('headwidth', .1)
                hl = s.get('headlength', .2)
                ax.arrow(start[0],
                         start[1],
                         end[0] - start[0],
                         end[1] - start[1],
                         head_width=hw,
                         head_length=hl,
                         length_includes_head=True,
                         color=self.color,
                         lw=self.lw)

        for label, loc, align, size in self.strs:
            loc = self.translate(np.array(loc))
            ha = align[0]
            va = align[1]
            ax.text(loc[0],
                    loc[1],
                    label,
                    transform=ax.transData,
                    horizontalalignment=ha,
                    verticalalignment=va,
                    fontsize=size)
Ejemplo n.º 14
0
def plot_loads_old(model, load_group, title, save_plot=False):
    """
    Takes the structure and load dictionary.
    
    Displays the structure with the user defined loads
    
    TO DO: display of forced rotations
    """
    # Settings
    # ------------------------------------
    forceColor = 'red'
    displacementColor = 'green'
    MomentColor = 'blue'
    # ------------------------------------

    try:
        nodalLoads = model['Loads'][load_group]['Nodal']
    except:
        nodalLoads = []

    try:
        pointLoads = model['Loads'][load_group]['Point']
    except:
        pointLoads = []

    try:
        lineLoads = model['Loads'][load_group]['Distributed']
    except:
        lineLoads = []

    try:
        functionLoads = model['Loads'][load_group]['Functions']
    except:
        functionLoads = []

    try:
        displacements = model['Loads'][load_group]['Initial Displacements']
    except:
        displacements = []

    elements = model['Beams']['Nodes']
    nodes = model['Nodes']['Location']

    # Determine Scaling Factors
    # ------------------------------------

    x_min = min([node[0] for node in nodes])
    x_max = max([node[0] for node in nodes])
    z_min = min([node[1] for node in nodes])
    z_max = max([node[1] for node in nodes])
    length = (((x_max - x_min)**2 + (z_max - z_min)**2)**0.5)

    scaleDisplacements = 20
    max_nodal = max([
        max(abs(nodalload[1]), abs(nodalload[2])) for nodalload in nodalLoads
    ] + [0])
    max_point = max([
        max(abs(pointload[2]), abs(pointload[3])) for pointload in pointLoads
    ] + [0])
    max_force = max(max_point, max_nodal, 0.0001)
    max_length = length / 18
    min_length = length / 100

    max_distributed = max([
        max(abs(lineload[3]), abs(lineload[6]), abs(lineload[4]),
            abs(lineload[7]), abs(lineload[5]), abs(lineload[8]))
        for lineload in lineLoads
    ] + [0])
    values_functions = []
    for functionload in functionLoads:
        for i in range(3):
            if functionload[3 + i] != 0 and functionload[3 + i] != None:
                values_functions.extend([
                    abs(functionload[3 + i](x)) for x in np.linspace(
                        functionload[1], functionload[2], num=15)
                ])
    max_functional = max(values_functions + [0])
    scaleDistributedForces = length / 8 / max(max_distributed, max_functional,
                                              0.0001)
    # ------------------------------------

    # Set up the plot
    fig, ax = initialize_plot()
    plotTitle(fig, 'Structure and Loads')
    plotStructure(model, ax)
    showOrientation(model, ax)
    plot_supports(model, ax)
    # if 'Releases' in model['Beams']:
    # plotHinges(model, ax)

    # Add identifiers for legend
    ax.plot(
        0,
        0,
        color=displacementColor,
        label=f'Forced Displacement (scaled by factor {scaleDisplacements})')
    ax.plot(0, 0, color=forceColor, label='Force')
    ax.plot(0, 0, color=MomentColor, label='Moment')

    # Cycle through nodal Forces
    for i in range(len(nodalLoads)):
        Fx = np.sign(nodalLoads[i][1]) * max(
            abs(nodalLoads[i][1]) / max_force * max_length, min_length)
        Fy = np.sign(nodalLoads[i][2]) * max(
            abs(nodalLoads[i][2]) / max_force * max_length, min_length)
        Mz = nodalLoads[i][3]

        if (abs(Fx) + abs(Fy)) > 0:
            targetX = nodes[nodalLoads[i][0]][0]
            targetY = nodes[nodalLoads[i][0]][1]
            arrow = FancyArrow(targetX,
                               targetY,
                               Fx,
                               Fy,
                               length_includes_head=True,
                               head_width=3,
                               linewidth=2,
                               color=forceColor,
                               zorder=10)
            ax.add_patch(arrow)
        if Mz != 0:
            targetX = nodes[nodalLoads[i][0]][0]
            targetY = nodes[nodalLoads[i][0]][1]
            #            ax.plot(targetX,targetY, marker='o', markersize=4, alpha=1, color=MomentColor)

            if Mz > 0:
                arc = Arc([targetX, targetY],
                          1,
                          1,
                          0,
                          240,
                          110,
                          linewidth=2,
                          color=MomentColor,
                          zorder=5)
                ax.add_patch(arc)
                arrow = FancyArrow(targetX - 0.35255,
                                   targetY + 0.35405,
                                   -0.01,
                                   -0.005,
                                   length_includes_head=True,
                                   head_width=3,
                                   linewidth=0.5,
                                   color=MomentColor,
                                   zorder=5)
            else:
                arc = Arc([targetX, targetY],
                          1,
                          1,
                          0,
                          70,
                          300,
                          linewidth=2,
                          color=MomentColor,
                          zorder=5)
                ax.add_patch(arc)
                arrow = FancyArrow(targetX + 0.35255,
                                   targetY + 0.35405,
                                   +0.01,
                                   -0.005,
                                   length_includes_head=True,
                                   head_width=3,
                                   linewidth=0.5,
                                   color=MomentColor,
                                   zorder=5)
            ax.add_patch(arrow)

    # Cycle through elements
    for i in range(len(elements)):
        elementVector = [
            nodes[elements[i][1]][0] - nodes[elements[i][0]][0],
            nodes[elements[i][1]][1] - nodes[elements[i][0]][1]
        ]
        elementVector = elementVector / np.linalg.norm(elementVector)

        # Plot point loads
        for j in range(len(pointLoads)):
            if int(pointLoads[j][0]) == i:
                loc = pointLoads[j][1]
                Fx = pointLoads[j][2] * scaleForces
                Fy = pointLoads[j][3] * scaleForces
                Mz = pointLoads[j][4]

                # Prevent error of arrow without length
                if (abs(Fx) + abs(Fy)) > 0:
                    targetX = nodes[elements[i][0]][0] + elementVector[0] * loc
                    targetY = nodes[elements[i][0]][1] + elementVector[1] * loc

                    arrow = FancyArrow(targetX - Fx,
                                       targetY - Fy,
                                       Fx,
                                       Fy,
                                       length_includes_head=True,
                                       head_width=4,
                                       linewidth=2,
                                       color=forceColor,
                                       zorder=10)
                    ax.add_patch(arrow)
                if Mz != 0:
                    targetX = nodes[elements[i][0]][0] + elementVector[0] * loc
                    targetY = nodes[elements[i][0]][1] + elementVector[1] * loc
                    ax.plot(targetX,
                            targetY,
                            marker='o',
                            markersize=4,
                            alpha=1,
                            color=MomentColor)

                    if Mz > 0:
                        arc = Arc([targetX, targetY],
                                  1,
                                  1,
                                  0,
                                  240,
                                  110,
                                  linewidth=2,
                                  color=MomentColor,
                                  zorder=5)
                        ax.add_patch(arc)
                        arrow = FancyArrow(targetX - 0.35255,
                                           targetY + 0.35405,
                                           -0.01,
                                           -0.005,
                                           length_includes_head=True,
                                           head_width=0.2,
                                           linewidth=0.5,
                                           color=MomentColor,
                                           zorder=5)
                    else:
                        arc = Arc([targetX, targetY],
                                  1,
                                  1,
                                  0,
                                  70,
                                  300,
                                  linewidth=2,
                                  color=MomentColor,
                                  zorder=5)
                        ax.add_patch(arc)
                        arrow = FancyArrow(targetX + 0.35255,
                                           targetY + 0.35405,
                                           +0.01,
                                           -0.005,
                                           length_includes_head=True,
                                           head_width=0.2,
                                           linewidth=0.5,
                                           color=MomentColor,
                                           zorder=5)
                    ax.add_patch(arrow)

        # Plot line loads
        for j in range(len(lineLoads)):
            if int(lineLoads[j][0]) == i:
                lStart = lineLoads[j][1]
                lEnd = lineLoads[j][2]
                qxStart = lineLoads[j][3] * scaleDistributedForces
                qyStart = lineLoads[j][4] * scaleDistributedForces
                mzStart = lineLoads[j][5] * scaleDistributedForces

                qxEnd = lineLoads[j][6] * scaleDistributedForces
                qyEnd = lineLoads[j][7] * scaleDistributedForces
                mzEnd = lineLoads[j][8] * scaleDistributedForces

                if qxStart != 0 or qyStart != 0 or qxEnd != 0 or qyEnd != 0:
                    targetXStart = nodes[elements[i]
                                         [0]][0] + elementVector[0] * lStart
                    targetXEnd = nodes[elements[i]
                                       [0]][0] + elementVector[0] * lEnd
                    targetYStart = nodes[elements[i]
                                         [0]][1] + elementVector[1] * lStart
                    targetYEnd = nodes[elements[i]
                                       [0]][1] + elementVector[1] * lEnd

                    x = [targetXEnd - qxEnd, targetXStart - qxStart]
                    y = [targetYEnd - qyEnd, targetYStart - qyStart]
                    ax.plot(x, y, color=forceColor, linewidth=1.3)

                    # draw Arrows
                    amount = int((lEnd - lStart) / (length / 20) + 2)
                    for k in range(amount):
                        l = lStart + (lEnd - lStart) * k / (amount - 1)
                        x = nodes[elements[i][0]][0] + elementVector[0] * l
                        y = nodes[elements[i][0]][1] + elementVector[1] * l
                        arrowlengthx = (lEnd - l) / (
                            lEnd - lStart) * qxStart + (l - lStart) / (
                                lEnd - lStart) * qxEnd
                        arrowlengthy = (lEnd - l) / (
                            lEnd - lStart) * qyStart + (l - lStart) / (
                                lEnd - lStart) * qyEnd
                        if abs(arrowlengthx) > length / 100 or abs(
                                arrowlengthy) > length / 100:
                            arrow = FancyArrow(x - arrowlengthx,
                                               y - arrowlengthy,
                                               arrowlengthx,
                                               arrowlengthy,
                                               length_includes_head=True,
                                               head_width=4,
                                               linewidth=1,
                                               color=forceColor,
                                               zorder=5)
                            ax.add_patch(arrow)

                if mzStart != 0 or mzEnd != 0:
                    targetXStart = nodes[elements[i]
                                         [0]][0] + elementVector[0] * lStart
                    targetXEnd = nodes[elements[i]
                                       [0]][0] + elementVector[0] * lEnd
                    targetYStart = nodes[elements[i]
                                         [0]][1] + elementVector[1] * lStart
                    targetYEnd = nodes[elements[i]
                                       [0]][1] + elementVector[1] * lEnd

                    x = [
                        targetXEnd - elementVector[1] * mzEnd,
                        targetXStart - elementVector[1] * mzStart
                    ]
                    y = [
                        targetYEnd + elementVector[0] * mzEnd,
                        targetYStart + elementVector[0] * mzStart
                    ]
                    ax.plot(x, y, color=MomentColor, lineWidth=1.3)

                    # draw Lines
                    amount = int((lEnd - lStart) / (length / 20) + 2)
                    for k in range(amount):
                        l = lStart + (lEnd - lStart) * k / (amount - 1)
                        x = nodes[elements[i][0]][0] + elementVector[0] * l
                        y = nodes[elements[i][0]][1] + elementVector[1] * l
                        arrowlengthx = -elementVector[1] * (
                            (lEnd - l) / (lEnd - lStart) * mzStart +
                            (l - lStart) / (lEnd - lStart) * mzEnd)
                        arrowlengthy = elementVector[0] * (
                            (lEnd - l) / (lEnd - lStart) * mzStart +
                            (l - lStart) / (lEnd - lStart) * mzEnd)
                        if abs(arrowlengthx) > length / 100 or abs(
                                arrowlengthy) > length / 100:
                            ax.plot([x, x + arrowlengthx],
                                    [y, y + arrowlengthy],
                                    color=MomentColor,
                                    lineWidth=1)

        # Plot forced displacements
        for j in range(len(displacements)):
            if int(displacements[j][0]) == i:
                if (abs(displacements[j][1] + abs(displacements[j][2]) > 0)):
                    arrow = FancyArrow(
                        nodes[int(displacements[j][0])][0],
                        nodes[int(displacements[j][0])][1],
                        scaleDisplacements * displacements[j][1],
                        scaleDisplacements * displacements[j][2],
                        length_includes_head=True,
                        head_width=0.2,
                        linewidth=2,
                        color=displacementColor)
                    ax.add_patch(arrow)

                if displacements[j][3] != 0:
                    targetX = nodes[displacements[i][0]][0]
                    targetY = nodes[displacements[i][0]][1]
                    ax.plot(targetX,
                            targetY,
                            marker='o',
                            markersize=4,
                            alpha=1,
                            color=displacementColor)
                    arc = Arc([targetX, targetY],
                              1,
                              1,
                              0,
                              240,
                              120,
                              linewidth=2,
                              color=displacementColor,
                              zorder=5)
                    ax.add_patch(arc)
                    if displacements[j][3] > 0:
                        arrow = FancyArrow(targetX - 0.35255,
                                           targetY + 0.35405,
                                           -0.01,
                                           -0.005,
                                           length_includes_head=True,
                                           head_width=0.2,
                                           linewidth=0.5,
                                           color=displacementColor,
                                           zorder=5)
                    else:
                        arrow = FancyArrow(targetX - 0.35255,
                                           targetY - 0.35405,
                                           -0.01,
                                           +0.005,
                                           length_includes_head=True,
                                           head_width=0.2,
                                           linewidth=0.5,
                                           color=displacementColor,
                                           zorder=5)
                    ax.add_patch(arrow)

        for j in range(len(functionLoads)):
            if int(functionLoads[j][0]) == i:

                lStart = functionLoads[j][1]
                lEnd = functionLoads[j][2]

                qx = functionLoads[j][3]
                qy = functionLoads[j][4]
                mz = functionLoads[j][5]

                if (qx != 0 and qx != None) or (qy != 0 and qy != None):
                    targetXStart = nodes[elements[i]
                                         [0]][0] + elementVector[0] * lStart
                    targetXEnd = nodes[elements[i]
                                       [0]][0] + elementVector[0] * lEnd
                    targetYStart = nodes[elements[i]
                                         [0]][1] + elementVector[1] * lStart
                    targetYEnd = nodes[elements[i]
                                       [0]][1] + elementVector[1] * lEnd

                    x1 = []
                    y1 = []

                    # draw Arrows
                    amount = int((lEnd - lStart) / (length / 20) + 2)
                    for k in range(amount * 4 - 3):
                        l = lStart + (lEnd - lStart) * k / ((
                            (4 * amount - 3)) - 1)
                        x = nodes[elements[i][0]][0] + elementVector[0] * l
                        y = nodes[elements[i][0]][1] + elementVector[1] * l
                        arrowlengthx = 0
                        arrowlengthy = 0
                        if (qx != 0 and qx != None):
                            arrowlengthx += qx(l) * scaleDistributedForces
                        if (qy != 0 and qy != None):
                            arrowlengthy += qy(l) * scaleDistributedForces

                        if ((abs(arrowlengthx) > length / 100
                             or abs(arrowlengthy) > length / 100)
                                and k % 4 == 0):
                            arrow = FancyArrow(x - arrowlengthx,
                                               y - arrowlengthy,
                                               arrowlengthx,
                                               arrowlengthy,
                                               length_includes_head=True,
                                               head_width=0.13,
                                               linewidth=1,
                                               color=forceColor,
                                               zorder=5)
                            ax.add_patch(arrow)
                        x1.append(x - arrowlengthx)
                        y1.append(y - arrowlengthy)
                    ax.plot(x1, y1, color=forceColor, lineWidth=1.3)

                if (mz != 0 and mz != None):
                    targetXStart = nodes[elements[i]
                                         [0]][0] + elementVector[0] * lStart
                    targetXEnd = nodes[elements[i]
                                       [0]][0] + elementVector[0] * lEnd
                    targetYStart = nodes[elements[i]
                                         [0]][1] + elementVector[1] * lStart
                    targetYEnd = nodes[elements[i]
                                       [0]][1] + elementVector[1] * lEnd

                    x1 = []
                    y1 = []

                    # draw Lines
                    amount = int((lEnd - lStart) / (length / 20) + 2)
                    for k in range(amount * 4 - 3):
                        l = lStart + (lEnd - lStart) * k / ((
                            (4 * amount - 3)) - 1)
                        x = nodes[elements[i][0]][0] + elementVector[0] * l
                        y = nodes[elements[i][0]][1] + elementVector[1] * l
                        arrowlengthx = -elementVector[1] * mz(l)
                        arrowlengthy = elementVector[0] * mz(l)
                        if ((abs(arrowlengthx) > length / 100
                             or abs(arrowlengthy) > length / 100)
                                and k % 4 == 0):
                            ax.plot([x, x + arrowlengthx],
                                    [y, y + arrowlengthy],
                                    color=MomentColor,
                                    lineWidth=1)
                        x1.append(x + arrowlengthx)
                        y1.append(y + arrowlengthy)
                    ax.plot(x1, y1, color=MomentColor, lineWidth=1.3)

    #plotLegend(ax)
    adjustPlot(ax)
    plt.show()
    if save_plot:
        fig.savefig(title + '.png')

    return ax
Ejemplo n.º 15
0
def create_ncaa_half_court(ax=None,
                           court_color='white',
                           lw=3,
                           lines_color='black',
                           lines_alpha=0.5,
                           paint_fill='Green',
                           paint_alpha=0.4):

    # combining two independent plots with matplotlib
    # ax = axes
    if ax is None:
        ax = plt.gca()

    # Center Circle
    # Circle(xy, radius, color, fill)
    center_circle = Circle((50 / 2, 94 / 2),
                           6,
                           linewidth=lw,
                           color=lines_color,
                           lw=lw,
                           fill=False,
                           alpha=lines_alpha)

    #Basketball Hoop
    hoop = Circle((50 / 2, 5.25),
                  1.5 / 2,
                  linewidth=lw,
                  color=lines_color,
                  lw=lw,
                  fill=False,
                  alpha=lines_alpha)

    # Paint - 18 Feet 10 inches which converts to 18.83333 feet
    # Rectangle(xy, width, height, linewidth, edgecolor, facecolor)
    paint = Rectangle(((50 / 2) - 6, 0),
                      12,
                      18.833333,
                      fill=paint_fill,
                      alpha=paint_alpha,
                      lw=lw,
                      edgecolor='Green')

    paint_boarder = Rectangle(((50 / 2) - 6, 0),
                              12,
                              18.833333,
                              fill=False,
                              alpha=lines_alpha,
                              lw=lw,
                              edgecolor=lines_color)

    arc = Arc((50 / 2, 18.833333),
              12,
              12,
              theta1=-0,
              theta2=180,
              color=lines_color,
              lw=lw,
              alpha=lines_alpha)

    # Add Patches
    ax.add_patch(paint)
    ax.add_patch(paint_boarder)
    ax.add_patch(center_circle)
    ax.add_patch(hoop)
    ax.add_patch(arc)

    block1 = Rectangle(((50 / 2) - 6 - 0.666, 7),
                       0.666,
                       1,
                       fill=True,
                       alpha=lines_alpha,
                       lw=0,
                       edgecolor=lines_color,
                       facecolor=lines_color)

    block2 = Rectangle(((50 / 2) + 6, 7),
                       0.666,
                       1,
                       fill=True,
                       alpha=lines_alpha,
                       lw=0,
                       edgecolor=lines_color,
                       facecolor=lines_color)

    # add a patch
    ax.add_patch(block1)
    ax.add_patch(block2)

    #lines on freethrow line

    l1 = Rectangle(((50 / 2) - 6 - 0.666, 11),
                   0.666,
                   0.166,
                   fill=True,
                   alpha=lines_alpha,
                   lw=0,
                   edgecolor=lines_color,
                   facecolor=lines_color)

    l2 = Rectangle(((50 / 2) - 6 - 0.666, 14),
                   0.666,
                   0.166,
                   fill=True,
                   alpha=lines_alpha,
                   lw=0,
                   edgecolor=lines_color,
                   facecolor=lines_color)

    l3 = Rectangle(((50 / 2) - 6 - 0.666, 17),
                   0.666,
                   0.166,
                   fill=True,
                   alpha=lines_alpha,
                   lw=0,
                   edgecolor=lines_color,
                   facecolor=lines_color)

    l4 = Rectangle(((50 / 2) + 6, 11),
                   0.666,
                   0.166,
                   fill=True,
                   alpha=lines_alpha,
                   lw=0,
                   edgecolor=lines_color,
                   facecolor=lines_color)

    l5 = Rectangle(((50 / 2) + 6, 14),
                   0.666,
                   0.166,
                   fill=True,
                   alpha=lines_alpha,
                   lw=0,
                   edgecolor=lines_color,
                   facecolor=lines_color)

    l6 = Rectangle(((50 / 2) + 6, 17),
                   0.666,
                   0.166,
                   fill=True,
                   alpha=lines_alpha,
                   lw=0,
                   edgecolor=lines_color,
                   facecolor=lines_color)

    ax.add_patch(l1)
    ax.add_patch(l2)
    ax.add_patch(l3)
    ax.add_patch(l4)
    ax.add_patch(l5)
    ax.add_patch(l6)

    # 3 Point Line !!!

    three_pt = Arc((50 / 2, 6.25),
                   44.291,
                   44.291,
                   theta1=12,
                   theta2=168,
                   color=lines_color,
                   lw=lw,
                   alpha=lines_alpha)

    ax.plot((3.34, 3.34), (0, 11.20),
            color=lines_color,
            lw=lw,
            alpha=lines_alpha)

    ax.plot((50 - 3.34, 50 - 3.34), (0, 11.20),
            color=lines_color,
            lw=lw,
            alpha=lines_alpha)

    ax.add_patch(three_pt)

    inner_arc = Arc((50 / 2, 18.833333),
                    12,
                    12,
                    theta1=180,
                    theta2=0,
                    color=lines_color,
                    lw=lw,
                    alpha=lines_alpha,
                    ls='--')

    ax.add_patch(inner_arc)

    # Restricted Area Marker
    restricted_area = Arc((50 / 2, 6.25),
                          8,
                          8,
                          theta1=0,
                          theta2=180,
                          color=lines_color,
                          lw=lw,
                          alpha=lines_alpha)
    ax.add_patch(restricted_area)

    # Backboard
    ax.plot(((50 / 2) - 3, (50 / 2) + 3), (4, 4),
            color=lines_color,
            lw=lw * 1.5,
            alpha=lines_alpha)

    ax.plot((50 / 2, 50 / 2), (4.3, 4),
            color=lines_color,
            lw=lw,
            alpha=lines_alpha)

    # Half Court Line
    ax.axhline(94 / 2, color=lines_color, lw=lw, alpha=lines_alpha)

    ax.set_xlim(0, 50)
    ax.set_ylim(0, 94 / 2 + 2)
    ax.set_facecolor(court_color)
    ax.set_xticks([])
    ax.set_yticks([])
    ax.set_xlabel('')
    return ax
Ejemplo n.º 16
0
def draw_court(ax=None, color='black', lw=2, outer_lines=False):
    # 如果坐标轴对象不提供绘图,就创建一个
    if ax is None:
        ax = plt.gca()

    # 创建 NBA 篮球场

    # 绘制篮球框
    # 直径18的篮球框
    # 7.5在坐标中
    hoop = Circle((0, 0), radius=7.5, linewidth=lw, color=color, fill=False)

    # 绘制篮板
    backboard = Rectangle((-30, -7.5), 60, -1, linewidth=lw, color=color)

    # The paint
    # 绘制矩形宽 16ft, 高 19ft
    outer_box = Rectangle((-80, -47.5),
                          160,
                          190,
                          linewidth=lw,
                          color=color,
                          fill=False)
    # 绘制里面的小矩形, widt=12ft, height=19ft
    inner_box = Rectangle((-60, -47.5),
                          120,
                          190,
                          linewidth=lw,
                          color=color,
                          fill=False)

    # 绘制罚球顶弧
    top_free_throw = Arc((0, 142.5),
                         120,
                         120,
                         theta1=0,
                         theta2=180,
                         linewidth=lw,
                         color=color,
                         fill=False)
    # 绘制罚球低弧
    bottom_free_throw = Arc((0, 142.5),
                            120,
                            120,
                            theta1=180,
                            theta2=0,
                            linewidth=lw,
                            color=color,
                            linestyle='dashed')
    # 限制区, 以篮筐为中心,半径为 4ft的弧
    restricted = Arc((0, 0),
                     80,
                     80,
                     theta1=0,
                     theta2=180,
                     linewidth=lw,
                     color=color)

    # 三分线
    # 绘制三分线边线,长 14ft
    corner_three_a = Rectangle((-220, -47.5),
                               0,
                               140,
                               linewidth=lw,
                               color=color)
    corner_three_b = Rectangle((220, -47.5), 0, 140, linewidth=lw, color=color)
    # 三分线弧度,以篮筐为中心,离篮筐23.9
    three_arc = Arc((0, 0),
                    475,
                    475,
                    theta1=22,
                    theta2=158,
                    linewidth=lw,
                    color=color)

    # 球场中心
    center_outer_arc = Arc((0, 422.5),
                           120,
                           120,
                           theta1=180,
                           theta2=0,
                           linewidth=lw,
                           color=color)
    center_inner_arc = Arc((0, 422.5),
                           40,
                           40,
                           theta1=180,
                           theta2=0,
                           linewidth=lw,
                           color=color)

    # 将上面写的球场属性用列表在轴上画出来
    court_elements = [
        hoop, backboard, outer_box, inner_box, top_free_throw,
        bottom_free_throw, restricted, corner_three_a, corner_three_b,
        three_arc, center_outer_arc, center_inner_arc
    ]

    if outer_lines:
        # 画半场线,基础线以及边缘线
        outer_lines = Rectangle((-250, -47.5),
                                500,
                                470,
                                linewidth=lw,
                                color=color,
                                fill=False)
        court_elements.append(outer_lines)

    # 添加球场元素到坐标上
    for element in court_elements:
        ax.add_patch(element)

    return ax
Ejemplo n.º 17
0
    def draw(self, ax, showframe=False):
        """ Draw the element
            ax        : matplotlib axis
            showframe : Draw the axis frame. Useful for debugging.
        """
        if self.fill:
            for i in range(len(self.paths)):
                tlist = [(x,y) for x, y in self.paths[i]]  # Need tuples for set hashing
                if len(tlist) != len(set(tlist)):  # duplicate points, assume closed shape
                    ax.fill(*list(zip(*self.paths[i])), color=self.fill, zorder=0)
        
        for path in self.paths:
            ax.plot(path[:, 0], path[:, 1], color=self.color, lw=self.lw,
                    solid_capstyle='round', ls=self.ls)

        for s in self.shapes:
            if s.get('fill', False):
                fill = True
                fillcolor = s.get('fillcolor', self.color)
            else:
                fill = self.fill is not None
                fillcolor = self.fill
            
            if s.get('shape') == 'circle':
                xy = np.array(s.get('center', [0, 0]))
                xy = self.translate(xy - self.ofst)
                rad = s.get('radius', 1) * self.z
                circ = plt.Circle(xy=xy, radius=rad, ec=self.color,
                                  fc=fillcolor, fill=fill, zorder=0, lw=self.lw)
                ax.add_patch(circ)
            elif s.get('shape') == 'poly':
                xy = np.array(s.get('xy', [[0, 0]]))
                xy = self.translate(xy - self.ofst)
                closed = s.get('closed', True)
                poly = plt.Polygon(xy=xy, closed=closed, ec=self.color,
                                   fc=fillcolor, fill=fill, zorder=0, lw=self.lw)
                ax.add_patch(poly)
            elif s.get('shape') == 'arc':
                xy = np.array(s.get('center', [0, 0]))
                xy = self.translate(xy - self.ofst)

                w = s.get('width', 1) * self.z
                h = s.get('height', 1) * self.z
                th1 = s.get('theta1', 35)
                th2 = s.get('theta2', -35)
                if self.reverse: th1, th2 = th1+180, th2+180

                angle = s.get('angle', self.theta)
                arc = Arc(xy, width=w, height=h, theta1=th1,
                          theta2=th2, angle=angle, color=self.color, lw=self.lw)
                ax.add_patch(arc)

                # Add an arrowhead to the arc
                arrow = s.get('arrow', None)  # 'cw' or 'ccw' or None
                if arrow is not None:
                    # Apply stretch to theta to match MPL's arc
                    # (See change https://github.com/matplotlib/matplotlib/pull/8047/files)
                    x, y = np.cos(np.deg2rad(th2)), np.sin(np.deg2rad(th2))
                    th2 = np.rad2deg(np.arctan2((w/h)*y, x))
                    x, y = np.cos(np.deg2rad(th1)), np.sin(np.deg2rad(th1))
                    th1 = np.rad2deg(np.arctan2((w/h)*y, x))
                    if arrow == 'ccw':
                        
                        dx = np.cos(np.deg2rad(th2+90)) / 100
                        dy = np.sin(np.deg2rad(th2+90)) / 100
                        s = [xy[0] + w/2*np.cos(np.deg2rad(th2)),
                             xy[1] + h/2*np.sin(np.deg2rad(th2))]
                    else:
                        dx = -np.cos(np.deg2rad(th1+90)) / 100
                        dy = - np.sin(np.deg2rad(th1+90)) / 100

                        s = [xy[0] + w/2*np.cos(np.deg2rad(th1)),
                             xy[1] + h/2*np.sin(np.deg2rad(th1))]

                    # Rotate the arrow head
                    co = np.cos(np.radians(angle))
                    so = np.sin(np.radians(angle))
                    m = np.array([[co, so],[-so, co]])
                    s = np.dot(s-xy, m)+xy
                    darrow = np.dot([dx, dy], m)

                    ax.arrow(s[0], s[1], darrow[0], darrow[1], head_width=.15,
                             head_length=.25, color=self.color)

            elif s.get('shape') == 'arrow':
                start = np.array(s.get('start', [0, 0]))
                end = np.array(s.get('end', [1, 0]))
                start = self.translate(start - self.ofst)
                end = self.translate(end - self.ofst)
                hw = s.get('headwidth', .1)
                hl = s.get('headlength', .2)
                ax.arrow(start[0], start[1], end[0]-start[0], end[1]-start[1],
                         head_width=hw, head_length=hl,
                         length_includes_head=True, color=self.color, lw=self.lw)

        for label, loc, align, size in self.strs:
            loc = self.translate(np.array(loc))
            ha = align[0]
            va = align[1]
            ax.text(loc[0], loc[1], label, transform=ax.transData,
                    horizontalalignment=ha, verticalalignment=va,
                    fontsize=size)
Ejemplo n.º 18
0
    def drawCourt(self, ax=None, color='black', lw=2, outerLines=False):
        if ax is None:
            ax = plt.gca()
            # ax.set_axis_bgcolor('#FAFAFA')

        hoop = Circle((0, 0),
                      radius=7.5,
                      linewidth=lw,
                      color=color,
                      fill=False)
        backboard = Rectangle((-30, -7.5), 60, -1, linewidth=lw, color=color)
        outer_box = Rectangle((-80, -47.5),
                              160,
                              190,
                              linewidth=lw,
                              color=color,
                              fill=False)
        inner_box = Rectangle((-60, -47.5),
                              120,
                              190,
                              linewidth=lw,
                              color=color,
                              fill=False)
        top_free_throw = Arc((0, 142.5),
                             120,
                             120,
                             theta1=0,
                             theta2=180,
                             linewidth=lw,
                             color=color,
                             fill=False)
        bottom_free_throw = Arc((0, 142.5),
                                120,
                                120,
                                theta1=180,
                                theta2=0,
                                linewidth=lw,
                                color=color,
                                linestyle='dashed')
        restricted = Arc((0, 0),
                         80,
                         80,
                         theta1=0,
                         theta2=180,
                         linewidth=lw,
                         color=color)
        corner_three_a = Rectangle((-220, -47.5),
                                   0,
                                   140,
                                   linewidth=lw,
                                   color=color)
        corner_three_b = Rectangle((220, -47.5),
                                   0,
                                   140,
                                   linewidth=lw,
                                   color=color)
        three_arc = Arc((0, 0),
                        475,
                        475,
                        theta1=22,
                        theta2=158,
                        linewidth=lw,
                        color=color)
        center_outer_arc = Arc((0, 422.5),
                               120,
                               120,
                               theta1=180,
                               theta2=0,
                               linewidth=lw,
                               color=color)
        center_inner_arc = Arc((0, 422.5),
                               40,
                               40,
                               theta1=180,
                               theta2=0,
                               linewidth=lw,
                               color=color)
        court_elements = [
            hoop, backboard, outer_box, inner_box, top_free_throw,
            bottom_free_throw, restricted, corner_three_a, corner_three_b,
            three_arc, center_outer_arc, center_inner_arc
        ]
        if outerLines:
            outerLines = Rectangle((-250, -47.5),
                                   500,
                                   470,
                                   linewidth=lw,
                                   color=color,
                                   fill=False)
        court_elements.append(outerLines)
        for element in court_elements:
            ax.add_patch(element)
        return ax
Ejemplo n.º 19
0
def pitch(ax):
    # size of the pitch is 120, 80
    #Create figure

    #Pitch Outline & Centre Line
    plt.plot([0, 0], [0, 80], color="black")
    plt.plot([0, 120], [80, 80], color="black")
    plt.plot([120, 120], [80, 0], color="black")
    plt.plot([120, 0], [0, 0], color="black")
    plt.plot([60, 60], [0, 80], color="black")

    #Left Penalty Area
    plt.plot([14.6, 14.6], [57.8, 22.2], color="black")
    plt.plot([0, 14.6], [57.8, 57.8], color="black")
    plt.plot([0, 14.6], [22.2, 22.2], color="black")

    #Right Penalty Area
    plt.plot([120, 105.4], [57.8, 57.8], color="black")
    plt.plot([105.4, 105.4], [57.8, 22.5], color="black")
    plt.plot([120, 105.4], [22.5, 22.5], color="black")

    #Left 6-yard Box
    plt.plot([0, 4.9], [48, 48], color="black")
    plt.plot([4.9, 4.9], [48, 32], color="black")
    plt.plot([0, 4.9], [32, 32], color="black")

    #Right 6-yard Box
    plt.plot([120, 115.1], [48, 48], color="black")
    plt.plot([115.1, 115.1], [48, 32], color="black")
    plt.plot([120, 115.1], [32, 32], color="black")

    #Prepare Circles
    centreCircle = plt.Circle((60, 40), 8.1, color="black", fill=False)
    centreSpot = plt.Circle((60, 40), 0.71, color="black")
    leftPenSpot = plt.Circle((9.7, 40), 0.71, color="black")
    rightPenSpot = plt.Circle((110.3, 40), 0.71, color="black")

    #Draw Circles
    ax.add_patch(centreCircle)
    ax.add_patch(centreSpot)
    ax.add_patch(leftPenSpot)
    ax.add_patch(rightPenSpot)

    #Prepare Arcs
    # arguments for arc
    # x, y coordinate of centerpoint of arc
    # width, height as arc might not be circle, but oval
    # angle: degree of rotation of the shape, anti-clockwise
    # theta1, theta2, start and end location of arc in degree
    leftArc = Arc((9.7, 40),
                  height=16.2,
                  width=16.2,
                  angle=0,
                  theta1=310,
                  theta2=50,
                  color="black")
    rightArc = Arc((110.3, 40),
                   height=16.2,
                   width=16.2,
                   angle=0,
                   theta1=130,
                   theta2=230,
                   color="black")

    #Draw Arcs
    ax.add_patch(leftArc)
    ax.add_patch(rightArc)
Ejemplo n.º 20
0
def create_court(ax=None, color='black', lw=4):
    ax = plt.gca(xlim=[30, -30],
                 ylim=[-7, 43],
                 xticks=[],
                 yticks=[],
                 aspect=1.0)
    hoop = Circle((0, 0), radius=0.75, linewidth=lw, color=color)
    backboard = Rectangle((-3, -0.75), 6, -0.1, linewidth=lw, color=color)
    outer_box = Rectangle((-8, -5.25),
                          16,
                          19,
                          linewidth=lw,
                          color=color,
                          fill=False)
    inner_box = Rectangle((-6, -5.25),
                          12,
                          19,
                          linewidth=lw,
                          color=color,
                          fill=False)
    top_free_throw = Arc((0, 13.75),
                         12,
                         12,
                         theta1=0,
                         theta2=180,
                         linewidth=lw,
                         color=color,
                         fill=False)
    bottom_free_throw = Arc((0, 13.75),
                            12,
                            12,
                            theta1=180,
                            theta2=0,
                            linewidth=lw,
                            color=color,
                            linestyle='dashed')
    restricted = Arc((0, 0),
                     8,
                     8,
                     theta1=0,
                     theta2=180,
                     linewidth=lw,
                     color=color)
    corner_three_a = Rectangle((-22, -5.25),
                               0,
                               np.sqrt(23.75**2 - 22.0**2) + 5.25,
                               linewidth=lw,
                               color=color)
    corner_three_b = Rectangle((22, -5.25),
                               0,
                               np.sqrt(23.75**2 - 22.0**2) + 5.25,
                               linewidth=lw,
                               color=color)
    three_arc = Arc((0, 0),
                    47.5,
                    47.5,
                    theta1=np.arccos(22 / 23.75) * 180 / np.pi,
                    theta2=180.0 - np.arccos(22 / 23.75) * 180 / np.pi,
                    linewidth=lw,
                    color=color)
    court_elements = [
        hoop, backboard, outer_box, inner_box, top_free_throw,
        bottom_free_throw, restricted, corner_three_a, corner_three_b,
        three_arc
    ]
    ax.plot([-25, 25], [-5.25, -5.25], linewidth=lw, color=color)
    for element in court_elements:
        ax.add_patch(element)
    return ax
Ejemplo n.º 21
0
def court(ax=None, color='black', lw=4, outer_lines=False,direction='up',short_three=False):
    '''
    Plots an NBA court
    outer_lines - accepts False or True. Plots the outer side lines of the court.
    direction - 'up' or 'down' depending on how you like to view the court
    Original function from http://savvastjortjoglou.com/
    '''
    # If an axes object isn't provided to plot onto, just get current one
    if ax is None:
        if direction=='up':
            ax = plt.gca(xlim = [-30,30],ylim = [43,-7],xticks=[],yticks=[],aspect=1.0)
            plt.text(22,44,'By: Doingthedishes',color='black',horizontalalignment='center',fontsize=20,fontweight='bold')
        elif direction=='down':
            ax = plt.gca(xlim = [30,-30],ylim = [-7,43],xticks=[],yticks=[],aspect=1.0)
            plt.text(-22,-7,'By: Doingthedishes',color='black',horizontalalignment='center',fontsize=20,fontweight='bold')
        else:
            ax = plt.gca()
    # Create the various parts of an NBA basketball court

    # Create the basketball hoop
    # Diameter of a hoop is 1.5
    hoop = Circle((0, 0), radius=0.75, linewidth=lw/2, color=color, fill=False)

    # Create backboard
    backboard = Rectangle((-3, -0.75), 6, -0.1, linewidth=lw, color=color)

    # The paint
    # Create the outer box of the paint, width=16ft, height=19ft
    outer_box = Rectangle((-8, -5.25), 16, 19, linewidth=lw, color=color,
                          fill=False)
    # Create the inner box of the paint, widt=12ft, height=19ft
    inner_box = Rectangle((-6, -5.25), 12, 19, linewidth=lw, color=color,
                          fill=False)

    # Create free throw top arc
    top_free_throw = Arc((0, 13.75), 12, 12, theta1=0, theta2=180,
                         linewidth=lw, color=color, fill=False)
    # Create free throw bottom arc
    bottom_free_throw = Arc((0, 13.75), 12, 12, theta1=180, theta2=0,
                            linewidth=lw, color=color, linestyle='dashed')
    # Restricted Zone, it is an arc with 4ft radius from center of the hoop
    restricted = Arc((0, 0), 8, 8, theta1=0, theta2=180, linewidth=lw,
                     color=color)

    # Three point line
    if not short_three:
        corner_three_a = Rectangle((-22, -5.25), 0, np.sqrt(23.75**2-22.0**2)+5.25, linewidth=lw,
                                   color=color)
        corner_three_b = Rectangle((22, -5.25), 0, np.sqrt(23.75**2-22.0**2)+5.25, linewidth=lw, color=color)
        # 3pt arc - center of arc will be the hoop, arc is 23'9" away from hoop
        three_arc = Arc((0, 0), 47.5, 47.5, theta1=np.arccos(22/23.75)*180/np.pi, theta2=180.0-np.arccos(22/23.75)*180/np.pi, linewidth=lw,
                        color=color)
    else:
        corner_three_a = Rectangle((-22, -5.25), 0, 5.25, linewidth=lw,
                           color=color)
        corner_three_b = Rectangle((22, -5.25), 0, 5.25, linewidth=lw, color=color)
        # 3pt arc - center of arc will be the hoop, arc is 23'9" away from hoop
        three_arc = Arc((0, 0), 44.0, 44.0, theta1=0, theta2=180, linewidth=lw,
                        color=color)
        # List of the court elements to be plotted onto the axes
    court_elements = [hoop, backboard, outer_box, inner_box, top_free_throw,
                      bottom_free_throw, restricted, corner_three_a,
                      corner_three_b, three_arc]

    if outer_lines:
        # Draw the half court line, baseline and side out bound lines
        outer_lines = Rectangle((-25, -5.25), 50, 46.75, linewidth=lw,
                                color=color, fill=False)
        center_outer_arc = Arc((0, 41.25), 12, 12, theta1=180, theta2=0,
                                linewidth=lw, color=color)
        center_inner_arc = Arc((0, 41.25), 4, 4, theta1=180, theta2=0,
                                linewidth=lw, color=color)
        court_elements = court_elements + [outer_lines,center_outer_arc,center_inner_arc]
    else:
        ax.plot([-25,25],[-5.25,-5.25],linewidth=lw,color=color)
    # Add the court elements onto the axes
    for element in court_elements:
        ax.add_patch(element)
#    ax.axis('off')
    return ax
Ejemplo n.º 22
0
plt.setp(line_func,color = "blue", linewidth = 2)
plt.setp(line_y_f, color = "red", linewidth = 2)

plt.show()

from matplotlib.patches import Circle, Wedge, Ellipse, Arc, Rectangle

#figure = wedge((4, 4), 2, -90, 90)

figure = Wedge((4, 4), 2, -90, 90)

figure = Rectangle((10, 12), 5, 8)

#figure = Wedge((4, 4), 2, -90)

figure = Arc((6, 6), 5, 3, 0, 200, 100)

from matplotlib.patches import Path, PathPatch
import matplotlib.pyplot as plt

n = 8 # размер области

m  = 7 # размер области

plt.xlim(0, n)

plt.ylim(0,m)

ax = plt.gca()

# создать массив точек
Ejemplo n.º 23
0
def visualize_contour_for_synthetic_dataset(model,
                                            d_i,
                                            x_data,
                                            y_data,
                                            basis,
                                            with_LDS=False,
                                            epsilon=0.5,
                                            num_power_iter=5,
                                            save_filename='prob_cont'):

    linewidth = 10

    range_x = numpy.arange(-2.0, 2.1, 0.05)
    A_inv = linalg.inv(numpy.dot(basis, basis.T))
    train_x_org = numpy.dot(x_data, numpy.dot(basis.T, A_inv))
    test_x_org = numpy.zeros((range_x.shape[0]**2, 2))
    train_x_1_ind = numpy.where(y_data == 1)[0]
    train_x_0_ind = numpy.where(y_data == 0)[0]

    for i in xrange(range_x.shape[0]):
        for j in xrange(range_x.shape[0]):
            test_x_org[range_x.shape[0] * i + j, 0] = range_x[i]
            test_x_org[range_x.shape[0] * i + j, 1] = range_x[j]

    test_x = numpy.dot(test_x_org, basis)
    x = T.matrix()
    f_p_y_given_x = theano.function(inputs=[x], outputs=model.forward_test(x))
    pred = f_p_y_given_x(numpy.asarray(test_x, 'float32'))[:, 1]

    Z = numpy.zeros((range_x.shape[0], range_x.shape[0]))
    for i in xrange(range_x.shape[0]):
        for j in xrange(range_x.shape[0]):
            Z[i, j] = pred[range_x.shape[0] * i + j]

    Y, X = numpy.meshgrid(range_x, range_x)

    fontsize = 20
    rc = 'r'
    bc = 'b'

    if (d_i == 1):
        rescale = 1.0  #/numpy.sqrt(500)
        arc1 = Arc(xy=[0.5 * rescale, -0.25 * rescale],
                   width=2.0 * rescale,
                   height=2.0 * rescale,
                   angle=0,
                   theta1=270,
                   theta2=180,
                   linewidth=linewidth,
                   alpha=0.15,
                   color=rc)
        arc2 = Arc(xy=[-0.5 * rescale, +0.25 * rescale],
                   width=2.0 * rescale,
                   height=2.0 * rescale,
                   angle=0,
                   theta1=90,
                   theta2=360,
                   linewidth=linewidth,
                   alpha=0.15,
                   color=bc)
        fig = plt.gcf()
        fig.gca().add_artist(arc1)
        fig.gca().add_artist(arc2)
        plt.xticks(fontsize=fontsize)
        plt.yticks(fontsize=fontsize)
    else:
        rescale = 1.0  #/numpy.sqrt(500)
        circle1 = Circle((0, 0),
                         1.0 * rescale,
                         color=rc,
                         alpha=0.2,
                         fill=False,
                         linewidth=linewidth)
        circle2 = Circle((0, 0),
                         0.15 * rescale,
                         color=bc,
                         alpha=0.2,
                         fill=False,
                         linewidth=linewidth)
        fig = plt.gcf()
        fig.gca().add_artist(circle1)
        fig.gca().add_artist(circle2)
        plt.xticks(fontsize=fontsize)
        plt.yticks(fontsize=fontsize)

    levels = [0.05, 0.2, 0.35, 0.5, 0.65, 0.8, 0.95]
    cs = plt.contour(X * rescale,
                     Y * rescale,
                     Z,
                     7,
                     cmap='bwr',
                     vmin=0.,
                     vmax=1.0,
                     linewidths=8.,
                     levels=levels)
    cbar = plt.colorbar(cs)
    cbar.ax.tick_params(labelsize=fontsize)
    plt.setp(cs.collections, linewidth=1.0)
    plt.contour(X * rescale,
                Y * rescale,
                Z,
                1,
                cmap='binary',
                vmin=0,
                vmax=0.5,
                linewidths=2.0)

    plt.xlim([-2. * rescale, 2. * rescale])
    plt.ylim([-2. * rescale, 2. * rescale])
    plt.xticks([-2.0, -1.0, 0, 1, 2.0], fontsize=fontsize)
    plt.yticks([-2.0, -1.0, 0, 1, 2.0], fontsize=fontsize)

    plt.scatter(train_x_org[train_x_1_ind, 0] * rescale,
                train_x_org[train_x_1_ind, 1] * rescale,
                s=100,
                marker='o',
                c=rc,
                label='$y=1$')
    plt.scatter(train_x_org[train_x_0_ind, 0] * rescale,
                train_x_org[train_x_0_ind, 1] * rescale,
                s=100,
                marker='^',
                c=bc,
                label='$y=0$')

    if (with_LDS == True):
        x = T.matrix()
        f_LDS = theano.function(inputs=[],
                                outputs=LDS_finite_diff(
                                    x=x,
                                    forward_func=model.forward_test,
                                    main_obj_type='CE',
                                    epsilon=epsilon,
                                    norm_constraint='L2',
                                    num_power_iter=num_power_iter),
                                givens={x: x_data})
        ave_LDS = numpy.mean([f_LDS().mean() for i in xrange(50)])
        print ave_LDS
        plt.title('Average $\widetilde{\\rm LDS}=%.3f$' % round(ave_LDS, 3),
                  fontsize=fontsize)
    make_sure_path_exists("./figure")
    plt.savefig('figure/' + save_filename, transparent=True)
Ejemplo n.º 24
0
def create_smith():
    # Create the figure object
    fig = plt.figure(facecolor='white')

    # Add a single plot to the figure
    ax = fig.add_subplot(1, 1, 1, aspect='equal')
    #	fig.add_axes([0.05, 0.05, 1.1, 1.1])
    #	ax = fig.axes[0]

    # Remove the figure boundaries
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)

    ax.spines['top'].set_visible(False)
    ax.spines['bottom'].set_visible(False)
    ax.spines['left'].set_visible(False)
    ax.spines['right'].set_visible(False)

    # Add Smith-chart impedance circles
    Circ_zero = plt.Circle((0, 0),
                           radius=1.0,
                           linestyle='solid',
                           linewidth=2,
                           color='black',
                           fill=False)
    Circ_unity = plt.Circle((0.5, 0),
                            radius=0.5,
                            linestyle='solid',
                            linewidth=1,
                            color='grey',
                            fill=False)
    Circ_imag_low = Arc((1, -1),
                        2,
                        2,
                        angle=0.0,
                        theta1=90.0,
                        theta2=180.0,
                        linestyle='solid',
                        linewidth=1,
                        color='grey',
                        fill=False)
    Circ_imag_high = Arc((1, 1),
                         2,
                         2,
                         angle=0.0,
                         theta1=180.0,
                         theta2=270.0,
                         linestyle='solid',
                         linewidth=1,
                         color='grey',
                         fill=False)

    Real_Line = Line2D((-1, 1), (0, 0),
                       linestyle='solid',
                       linewidth=1,
                       color='grey')
    #ax.axhline(0,xmin=-1,xmax=1,linestyle='solid',linewidth=1,color='grey')

    ax.add_patch(Circ_imag_high)
    ax.add_patch(Circ_imag_low)
    ax.add_patch(Circ_unity)
    ax.add_patch(Circ_zero)
    ax.add_line(Real_Line)

    return fig
Ejemplo n.º 25
0
import matplotlib.pyplot as plt
from matplotlib.patches import Arc, Ellipse, Rectangle, Wedge

fig, ax = plt.subplots(subplot_kw={"aspect": "equal"})

# 底部阴影
shadow = Ellipse((2.5, 0.5), 4.2, 0.5, color="#888888", alpha=0.2)

# 底座
ax.plot([1, 4], [1, 1.3], color="#000000")
base = Arc((2.5, 1.1),
           3,
           1,
           angle=10,
           theta1=0,
           theta2=180,
           color="#000000",
           alpha=0.8)

# 轮子
left_wheel = Ellipse((1, 1), 0.7, 0.4, angle=95, color="#000000")
right_wheel = Ellipse((4, 1.3), 0.7, 0.4, angle=85, color="#000000")

# 底部关节
bottom_join1 = Ellipse((2.5, 2), 1, 0.3, color="#888888", alpha=0.2)
bottom_join2 = Ellipse((2.5, 1.7), 1, 0.3, color="#888888", alpha=0.2)

# 肩膀关节
left_shoulder = Ellipse((1, 5.75), 0.5, 0.25, angle=90, color="#000000")
right_shoulder = Ellipse((4, 5.75), 0.5, 0.25, angle=90, color="#000000")
Ejemplo n.º 26
0
def draw_court(ax=None, color='black', lw=2, outer_lines=False):
    '''Draws NBA court on axis. 
    Source: http://savvastjortjoglou.com/nba-shot-sharts.html'''
    # If an axes object isn't provided to plot onto, just get current one
    if ax is None:
        ax = plt.gca()

    # Create the various parts of an NBA basketball court

    # Create the basketball hoop
    # Diameter of a hoop is 18" so it has a radius of 9", which is a value
    # 7.5 in our coordinate system
    hoop = Circle((0, 0), radius=7.5, linewidth=lw, color=color, fill=False)

    # Create backboard
    backboard = Rectangle((-30, -7.5), 60, -1, linewidth=lw, color=color)

    # The paint
    # Create the outer box 0f the paint, width=16ft, height=19ft
    outer_box = Rectangle((-80, -47.5),
                          160,
                          190,
                          linewidth=lw,
                          color=color,
                          fill=False)
    # Create the inner box of the paint, widt=12ft, height=19ft
    inner_box = Rectangle((-60, -47.5),
                          120,
                          190,
                          linewidth=lw,
                          color=color,
                          fill=False)

    # Create free throw top arc
    top_free_throw = Arc((0, 142.5),
                         120,
                         120,
                         theta1=0,
                         theta2=180,
                         linewidth=lw,
                         color=color,
                         fill=False)
    # Create free throw bottom arc
    bottom_free_throw = Arc((0, 142.5),
                            120,
                            120,
                            theta1=180,
                            theta2=0,
                            linewidth=lw,
                            color=color,
                            linestyle='dashed')
    # Restricted Zone, it is an arc with 4ft radius from center of the hoop
    restricted = Arc((0, 0),
                     80,
                     80,
                     theta1=0,
                     theta2=180,
                     linewidth=lw,
                     color=color)

    # Three point line
    # Create the side 3pt lines, they are 14ft long before they begin to arc
    corner_three_a = Rectangle((-220, -47.5),
                               0,
                               140,
                               linewidth=lw,
                               color=color)
    corner_three_b = Rectangle((220, -47.5), 0, 140, linewidth=lw, color=color)
    # 3pt arc - center of arc will be the hoop, arc is 23'9" away from hoop
    # I just played around with the theta values until they lined up with the
    # threes
    three_arc = Arc((0, 0),
                    475,
                    475,
                    theta1=22,
                    theta2=158,
                    linewidth=lw,
                    color=color)

    # Center Court
    center_outer_arc = Arc((0, 422.5),
                           120,
                           120,
                           theta1=180,
                           theta2=0,
                           linewidth=lw,
                           color=color)
    center_inner_arc = Arc((0, 422.5),
                           40,
                           40,
                           theta1=180,
                           theta2=0,
                           linewidth=lw,
                           color=color)

    # List of the court elements to be plotted onto the axes
    court_elements = [
        hoop, backboard, outer_box, inner_box, top_free_throw,
        bottom_free_throw, restricted, corner_three_a, corner_three_b,
        three_arc, center_outer_arc, center_inner_arc
    ]

    if outer_lines:
        # Draw the half court line, baseline and side out bound lines
        outer_lines = Rectangle((-250, -47.5),
                                500,
                                470,
                                linewidth=lw,
                                color=color,
                                fill=False)
        court_elements.append(outer_lines)

    # Add the court elements onto the axes
    for element in court_elements:
        ax.add_patch(element)

    return ax
Ejemplo n.º 27
0
def golden_curve(max_n=10):
    """ Plot the golden curve """

    # List of fibonacci numbers as (fn, fn-1) pair
    fibs = list(fibonacci(max_n))
    # Reverse as we need to generate rectangles
    # from large -> small
    fibs.reverse()

    fig, ax = plt.subplots(1)

    last_x, last_y = fibs[0]

    # Make the plot size large enough to hold
    # the largest fibonacci number on both
    # x and y-axis.
    ax.set_xlim(0, last_x + 10)
    ax.set_ylim(0, last_y + 10) 
    plt.axis('off')

    origin = [0, 0]
    p = 0

    # Data for plotting arcs
    arc_points = []
    rects = []

    # Starting offset angle
    angle = 90

    for i,(cur_fn, prev_fn) in enumerate(fibs):
        if i > max_n: break

        # Current arc's radius
        arc_radius = cur_fn

        if i in fourth_series(max_n):
            # Every 4th rectangle from the 2nd
            # rectangle onwards has its origin-x
            # point shifted by the fibonacci value
            origin[0] = origin[0] + cur_fn

        elif i in sixth_series(max_n):
            # Every 6th rectangle from the 5th
            # rectangle onwards has its origin-y
            # point shifted by the fibonacci value          
            origin[1] = origin[1] + cur_fn
            
        if i%2 == 0:
            # Every 2nd rectangle has its orientation
            # switched from lxb to bxl          
            cur_fn, prev_fn = prev_fn, cur_fn

        rectangle = Rectangle(origin, prev_fn, cur_fn, angle=0.0, antialiased=True)
        rects.append(rectangle)
        if i == 0: continue
        
        if i  % 8 == 0:
            p += 1
            continue

        if len(arc_points) == 8: continue

        r1 = rectangle
        # Calculate the rectangle's co-ordinates
        coords = [r1.get_xy(), [r1.get_x()+r1.get_width(), r1.get_y()],
                  [r1.get_x()+r1.get_width(), r1.get_y()+r1.get_height()],
                  [r1.get_x(), r1.get_y()+r1.get_height()]]

        # Successive arcs are centered on the points of rectangles
        # which is calculated as the p % 4 the item
        arc_points.append((coords[p % 4], arc_radius, angle))
        # Every turn of the spiral we go clockwise by 90 degrees
        # means the starting angle reduces by 90.
        angle -= 90

        # Reset to 0
        if angle == -360: angle = 0
        p += 3
            
    for center, radius, angle in arc_points:
        print('Plotting arc at center',center,'radius',radius, 'angle',angle)
        arc = Arc(center, radius*2, radius*2, angle=angle,
                  theta1=0, theta2=90.0, edgecolor='black',
                  antialiased=True)
        ax.add_patch(arc)
        
    rect_pcs = PatchCollection(rects, facecolor='g', alpha=0.4,
                              edgecolor='black')

    ax.add_collection(rect_pcs)
    
    plt.show()
Ejemplo n.º 28
0
def Pitch(ax,
          height=120,
          width=80,
          line_color="black",
          pitch_color="white",
          mode="full",
          pitch_linewidth=1):
    def int_angles(radius, h, k, line_x):
        """
        Calculate the intersection angles of the arc above the D-boxes
        
        Parameters: 
            radius (float): Radius of the arc
            h(float): x coordinate of the centre of the arc
            k(float): y coordiante of the centre of the arc
            line_x(float): x coordinate of the D-box or the line to be intersected by the arc
      
        Returns: 
            theta1(float): First intersection angle
            theta2(float): Second intersection angle
        """
        y1 = math.sqrt(radius**2 - (line_x - h)**2) + k
        y2 = math.sqrt(radius**2 - (line_x - h)**2) * -1 + k
        y = (y1 - y2) / 2
        theta1 = math.degrees(math.asin(y / radius))
        theta2 = 360 - theta1

        return theta1, theta2

    #Pitch Outline
    ax.plot([0, 0], [0, width], color=line_color, linewidth=pitch_linewidth)
    ax.plot([0, height], [width, width],
            color=line_color,
            linewidth=pitch_linewidth)
    ax.plot([height, height], [width, 0],
            color=line_color,
            linewidth=pitch_linewidth)
    ax.plot([height, 0], [0, 0], color=line_color, linewidth=pitch_linewidth)

    ##Halfway-line
    ax.plot([height / 2, height / 2], [0, width],
            color=line_color,
            linewidth=pitch_linewidth)

    #Left Penalty Area
    ax.plot([0, .15 * height], [.225 * width, .225 * width],
            color=line_color,
            linewidth=pitch_linewidth)
    ax.plot([.15 * height, .15 * height], [.225 * width, 0.775 * width],
            color=line_color,
            linewidth=pitch_linewidth)
    ax.plot([.15 * height, 0], [.775 * width, .775 * width],
            color=line_color,
            linewidth=pitch_linewidth)

    #Right Penalty Area
    ax.plot([.85 * height, height], [.15 * height, .15 * height],
            color=line_color,
            linewidth=pitch_linewidth)
    ax.plot([.85 * height, .85 * height], [.15 * height, .775 * width],
            color=line_color,
            linewidth=pitch_linewidth)
    ax.plot([.85 * height, height], [.775 * width, .775 * width],
            color=line_color,
            linewidth=pitch_linewidth)

    #6-yard box left
    ax.plot([0, .05 * height], [.375 * width, .375 * width],
            color=line_color,
            linewidth=pitch_linewidth)
    ax.plot([.05 * height, .05 * height], [.375 * width, width - .375 * width],
            color=line_color,
            linewidth=pitch_linewidth)
    ax.plot([0, .05 * height], [.625 * width, .625 * width],
            color=line_color,
            linewidth=pitch_linewidth)

    #6-yard box right
    ax.plot([.95 * height, height], [.375 * width, .375 * width],
            color=line_color,
            linewidth=pitch_linewidth)
    ax.plot([.95 * height, 114], [.375 * width, .625 * width],
            color=line_color,
            linewidth=pitch_linewidth)
    ax.plot([.95 * height, height], [.625 * width, .625 * width],
            color=line_color,
            linewidth=pitch_linewidth)

    #Prepare Circles
    centreCircle = plt.Circle((height / 2, width / 2),
                              .076 * height,
                              color=line_color,
                              fill=False,
                              zorder=5)
    centreSpot = plt.Circle((height / 2, width / 2), 0.8, color=line_color)
    leftPenSpot = plt.Circle((.1 * height, 40), 0.8, color=line_color)
    rightPenSpot = plt.Circle((.9 * height, 40), 0.8, color=line_color)

    #Prepare Arcs
    theta1, theta2 = int_angles(radius=height / 12,
                                h=.1 * height,
                                k=width / 2,
                                line_x=.15 * height)

    leftArc = Arc((.1 * height, 40),
                  height=0.15 * height,
                  width=0.15 * height,
                  angle=0,
                  theta1=theta2,
                  theta2=theta1,
                  color=line_color,
                  zorder=5)

    theta1, theta2 = int_angles(radius=height / 12,
                                h=.9 * height,
                                k=width / 2,
                                line_x=.85 * height)

    rightArc = Arc((.9 * height, 40),
                   height=0.15 * height,
                   width=0.15 * height,
                   angle=180,
                   theta1=theta2,
                   theta2=theta1,
                   color=line_color,
                   zorder=5)

    ##Add corner arcs
    left_bottom = Arc((0, 0),
                      height=.05 * height,
                      width=0.05 * height,
                      angle=270,
                      theta1=90,
                      theta2=180,
                      color=line_color,
                      zorder=5)

    left_top = Arc((0, width),
                   height=.05 * height,
                   width=0.05 * height,
                   angle=0,
                   theta1=270,
                   theta2=0,
                   color=line_color,
                   zorder=5)

    right_bottom = Arc((height, 0),
                       height=.05 * height,
                       width=0.05 * height,
                       angle=0,
                       theta1=90,
                       theta2=180,
                       color=line_color,
                       zorder=5)

    right_top = Arc((height, width),
                    height=.05 * height,
                    width=0.05 * height,
                    angle=90,
                    theta1=90,
                    theta2=180,
                    color=line_color,
                    zorder=5)

    #Goals
    ax.plot([0, 0], [.45 * width, .55 * width],
            color=line_color,
            linewidth=pitch_linewidth * 4)
    ax.plot([height, height], [.45 * width, .55 * width],
            color=line_color,
            linewidth=pitch_linewidth * 4)

    #Add patches
    ax.add_patch(leftArc)
    ax.add_patch(rightArc)

    ax.add_patch(centreCircle)
    ax.add_patch(centreSpot)
    ax.add_patch(leftPenSpot)
    ax.add_patch(rightPenSpot)

    if mode == "full":
        ax.add_patch(left_bottom)
        ax.add_patch(left_top)
        ax.add_patch(right_bottom)
        ax.add_patch(right_top)

    ax.set_aspect("equal")
    ax.axis("off")

    return ax
from matplotlib.patches import Wedge, Arc
import matplotlib.pyplot as plt

x = 6
y = 5

plt.xlim(0, x)
plt.ylim(0, y)

ax = plt.gca()

figure_w = Wedge((3, 1), 2, 45, 135)  # рисуем сектор (центр, радиус, углы)
ax.add_patch(figure_w)

figure_a = Arc((3, 1), 6, 6, 0, 45, 135, lw=3)
ax.add_patch(figure_a)

plt.grid()
plt.show()
Ejemplo n.º 30
0
def createPitch(length, width, unity, linecolor):  # in meters
    # Code by @JPJ_dejong
    """
    creates a plot in which the 'length' is the length of the pitch (goal to goal).
    And 'width' is the width of the pitch (sideline to sideline). 
    Fill in the unity in meters or in yards.

    """
    #Set unity
    if unity == "meters":
        # Set boundaries
        if length >= 120.5 or width >= 75.5:
            return (str(
                "Field dimensions are too big for meters as unity, didn't you mean yards as unity?\
                       Otherwise the maximum length is 120 meters and the maximum width is 75 meters. Please try again"
            ))
        #Run program if unity and boundaries are accepted
        else:
            #Create figure
            fig = plt.figure()
            #fig.set_size_inches(7, 5)
            ax = fig.add_subplot(1, 1, 1)

            #Pitch Outline & Centre Line
            plt.plot([0, 0], [0, width], color=linecolor)
            plt.plot([0, length], [width, width], color=linecolor)
            plt.plot([length, length], [width, 0], color=linecolor)
            plt.plot([length, 0], [0, 0], color=linecolor)
            plt.plot([length / 2, length / 2], [0, width], color=linecolor)

            #Left Penalty Area
            plt.plot([16.5, 16.5], [(width / 2 + 16.5), (width / 2 - 16.5)],
                     color=linecolor)
            plt.plot([0, 16.5], [(width / 2 + 16.5), (width / 2 + 16.5)],
                     color=linecolor)
            plt.plot([16.5, 0], [(width / 2 - 16.5), (width / 2 - 16.5)],
                     color=linecolor)

            #Right Penalty Area
            plt.plot([(length - 16.5), length], [(width / 2 + 16.5),
                                                 (width / 2 + 16.5)],
                     color=linecolor)
            plt.plot([(length - 16.5), (length - 16.5)], [(width / 2 + 16.5),
                                                          (width / 2 - 16.5)],
                     color=linecolor)
            plt.plot([(length - 16.5), length], [(width / 2 - 16.5),
                                                 (width / 2 - 16.5)],
                     color=linecolor)

            #Left 5-meters Box
            plt.plot([0, 5.5], [(width / 2 + 7.32 / 2 + 5.5),
                                (width / 2 + 7.32 / 2 + 5.5)],
                     color=linecolor)
            plt.plot([5.5, 5.5], [(width / 2 + 7.32 / 2 + 5.5),
                                  (width / 2 - 7.32 / 2 - 5.5)],
                     color=linecolor)
            plt.plot([5.5, 0.5], [(width / 2 - 7.32 / 2 - 5.5),
                                  (width / 2 - 7.32 / 2 - 5.5)],
                     color=linecolor)

            #Right 5 -eters Box
            plt.plot([length, length - 5.5], [(width / 2 + 7.32 / 2 + 5.5),
                                              (width / 2 + 7.32 / 2 + 5.5)],
                     color=linecolor)
            plt.plot(
                [length - 5.5, length - 5.5],
                [(width / 2 + 7.32 / 2 + 5.5), width / 2 - 7.32 / 2 - 5.5],
                color=linecolor)
            plt.plot([length - 5.5, length],
                     [width / 2 - 7.32 / 2 - 5.5, width / 2 - 7.32 / 2 - 5.5],
                     color=linecolor)

            #Prepare Circles
            centreCircle = plt.Circle((length / 2, width / 2),
                                      9.15,
                                      color=linecolor,
                                      fill=False)
            centreSpot = plt.Circle((length / 2, width / 2),
                                    0.8,
                                    color=linecolor)
            leftPenSpot = plt.Circle((11, width / 2), 0.8, color=linecolor)
            rightPenSpot = plt.Circle((length - 11, width / 2),
                                      0.8,
                                      color=linecolor)

            #Draw Circles
            ax.add_patch(centreCircle)
            ax.add_patch(centreSpot)
            ax.add_patch(leftPenSpot)
            ax.add_patch(rightPenSpot)

            #Prepare Arcs
            leftArc = Arc((11, width / 2),
                          height=18.3,
                          width=18.3,
                          angle=0,
                          theta1=308,
                          theta2=52,
                          color=linecolor)
            rightArc = Arc((length - 11, width / 2),
                           height=18.3,
                           width=18.3,
                           angle=0,
                           theta1=128,
                           theta2=232,
                           color=linecolor)

            #Draw Arcs
            ax.add_patch(leftArc)
            ax.add_patch(rightArc)
            #Axis titles

    #check unity again
    elif unity == "yards":
        #check boundaries again
        if length <= 95:
            return (str("Didn't you mean meters as unity?"))
        elif length >= 131 or width >= 101:
            return (str(
                "Field dimensions are too big. Maximum length is 130, maximum width is 100"
            ))
        #Run program if unity and boundaries are accepted
        else:
            #Create figure
            fig = plt.figure()
            #fig.set_size_inches(7, 5)
            ax = fig.add_subplot(1, 1, 1)

            #Pitch Outline & Centre Line
            plt.plot([0, 0], [0, width], color=linecolor)
            plt.plot([0, length], [width, width], color=linecolor)
            plt.plot([length, length], [width, 0], color=linecolor)
            plt.plot([length, 0], [0, 0], color=linecolor)
            plt.plot([length / 2, length / 2], [0, width], color=linecolor)

            #Left Penalty Area
            plt.plot([18, 18], [(width / 2 + 18), (width / 2 - 18)],
                     color=linecolor)
            plt.plot([0, 18], [(width / 2 + 18), (width / 2 + 18)],
                     color=linecolor)
            plt.plot([18, 0], [(width / 2 - 18), (width / 2 - 18)],
                     color=linecolor)

            #Right Penalty Area
            plt.plot([(length - 18), length], [(width / 2 + 18),
                                               (width / 2 + 18)],
                     color=linecolor)
            plt.plot([(length - 18), (length - 18)], [(width / 2 + 18),
                                                      (width / 2 - 18)],
                     color=linecolor)
            plt.plot([(length - 18), length], [(width / 2 - 18),
                                               (width / 2 - 18)],
                     color=linecolor)

            #Left 6-yard Box
            plt.plot([0, 6], [(width / 2 + 7.32 / 2 + 6),
                              (width / 2 + 7.32 / 2 + 6)],
                     color=linecolor)
            plt.plot([6, 6], [(width / 2 + 7.32 / 2 + 6),
                              (width / 2 - 7.32 / 2 - 6)],
                     color=linecolor)
            plt.plot([6, 0], [(width / 2 - 7.32 / 2 - 6),
                              (width / 2 - 7.32 / 2 - 6)],
                     color=linecolor)

            #Right 6-yard Box
            plt.plot([length, length - 6], [(width / 2 + 7.32 / 2 + 6),
                                            (width / 2 + 7.32 / 2 + 6)],
                     color=linecolor)
            plt.plot([length - 6, length - 6],
                     [(width / 2 + 7.32 / 2 + 6), width / 2 - 7.32 / 2 - 6],
                     color=linecolor)
            plt.plot([length - 6, length],
                     [(width / 2 - 7.32 / 2 - 6), width / 2 - 7.32 / 2 - 6],
                     color=linecolor)

            #Prepare Circles; 10 yards distance. penalty on 12 yards
            centreCircle = plt.Circle((length / 2, width / 2),
                                      10,
                                      color=linecolor,
                                      fill=False)
            centreSpot = plt.Circle((length / 2, width / 2),
                                    0.8,
                                    color=linecolor)
            leftPenSpot = plt.Circle((12, width / 2), 0.8, color=linecolor)
            rightPenSpot = plt.Circle((length - 12, width / 2),
                                      0.8,
                                      color=linecolor)

            #Draw Circles
            ax.add_patch(centreCircle)
            ax.add_patch(centreSpot)
            ax.add_patch(leftPenSpot)
            ax.add_patch(rightPenSpot)

            #Prepare Arcs
            leftArc = Arc((11, width / 2),
                          height=20,
                          width=20,
                          angle=0,
                          theta1=312,
                          theta2=48,
                          color=linecolor)
            rightArc = Arc((length - 11, width / 2),
                           height=20,
                           width=20,
                           angle=0,
                           theta1=130,
                           theta2=230,
                           color=linecolor)

            #Draw Arcs
            ax.add_patch(leftArc)
            ax.add_patch(rightArc)

    #Tidy Axes
    plt.axis('off')

    return fig, ax
Ejemplo n.º 31
0
def CreatePitch(i):
    """Function that draws a pitch with dimensions 105x68"""

    #Create figure
    fig = plt.figure(i, figsize=(6.4 * 2, 4.8 * 2))
    ax = fig.add_subplot(1, 1, 1)

    #Pitch Outline & Centre Line
    plt.plot([0, 0], [0, 68], color="black")
    plt.plot([0, 105], [68, 68], color="black")
    plt.plot([105, 105], [68, 0], color="black")
    plt.plot([105, 0], [0, 0], color="black")
    plt.plot([52.5, 52.5], [0, 68], color="black")

    #Left Penalty Area
    plt.plot([16.5, 16.5], [13.84, 54.16], color="black")
    plt.plot([0, 16.5], [54.16, 54.16], color="black")
    plt.plot([16.5, 0], [13.84, 13.84], color="black")

    #Left goal
    plt.plot([-2, -2], [30.34, 37.66], color="black")
    plt.plot([-2, 0], [30.34, 30.34], color="black")
    plt.plot([0, -2], [37.66, 37.66], color="black")

    #Right goal
    plt.plot([107, 107], [30.34, 37.66], color="black")
    plt.plot([107, 105], [30.34, 30.34], color="black")
    plt.plot([105, 107], [37.66, 37.66], color="black")

    #Right Penalty Area
    plt.plot([105, 88.5], [54.16, 54.16], color="black")
    plt.plot([88.5, 88.5], [54.16, 13.84], color="black")
    plt.plot([88.5, 105], [13.84, 13.84], color="black")

    #Left Small Area
    plt.plot([0, 5.5], [43.16, 43.16], color="black")
    plt.plot([5.5, 5.5], [43.16, 24.84], color="black")
    plt.plot([5.5, 0], [24.84, 24.84], color="black")

    #Right Small Area
    plt.plot([105, 99.5], [43.16, 43.16], color="black")
    plt.plot([99.5, 99.5], [43.16, 24.84], color="black")
    plt.plot([99.5, 105], [24.84, 24.84], color="black")

    #Prepare Circles
    centreCircle = plt.Circle((52.5, 34), 9.15, color="black", fill=False)
    centreSpot = plt.Circle((52.5, 34), 0.4, color="black", fill=False)
    leftPenSpot = plt.Circle((11, 34), 0.4, color="black", fill=False)
    rightPenSpot = plt.Circle((94, 34), 0.4, color="black", fill=False)

    #Draw Circles
    ax.add_patch(centreCircle)
    ax.add_patch(centreSpot)
    ax.add_patch(leftPenSpot)
    ax.add_patch(rightPenSpot)

    #Prepare Arcs
    leftArc = Arc((11, 34),
                  height=16.4,
                  width=18.3,
                  angle=0,
                  theta1=310,
                  theta2=50,
                  color="black")
    rightArc = Arc((94, 34),
                   height=16.4,
                   width=18.3,
                   angle=0,
                   theta1=130,
                   theta2=230,
                   color="black")

    #Draw Arcs
    ax.add_patch(leftArc)
    ax.add_patch(rightArc)

    #Tidy Axes
    plt.gca().invert_yaxis()

    return
Ejemplo n.º 32
0
    def onDrawRose(self, event):
        """ Rose Diagram Options """

        try:  # the 'except' for this 'try' is about 200 lines ahead!

            i = self.file_i

            ddirRb = self.rbddir.GetValue()
            strkRb = self.rbstrk.GetValue()
            trndRb = self.rbtrd.GetValue()
            r360 = self.rb360.GetValue()
            r180 = self.rb180.GetValue()
            frequency = self.rbfreq.GetValue()
            weighted = self.rbwgt.GetValue()
            petal = self.spin.GetValue()
            outer_circ = self.spin2.GetValue()
            inner_rings = self.spin3.GetValue()
            diagonals = self.spin4.GetValue()
            fillcolor = self.fcolor
            edgecolor = self.lcolor

            fontsize = self.fontSize

            showMean = self.cb_mean.GetValue()
            meancolor = self.mcolor
            meanwidth = self.spin5.GetValue()

            ring_steps = inner_rings / float(outer_circ)
            grid_col = 'grey'
            grid_width = 0.5

            self.plotaxes2.cla()
            axes = self.plotaxes2
            self.plotaxes2.set_axis_off()

            # create empty lists
            Azimuth = []
            Dip = []
            ddir = []
            dp = []
            strk = []
            trd = []
            plng = []

            # what kind of data was selected
            if self.nametype == 1:  # 1 == itemPlanar
                ddir = self.Pazim[i]
                dp = self.Pdip[i]
                strk = self.Pstrike[i]
                if self.Pidx[i].startswith('D'):  # dip-dir data
                    name = '[P(dd)] %s' % self.Pname[i]
                else:  # right-hand data
                    name = '[P(rh)] %s' % self.Pname[i]
            elif self.nametype == 2:  # 2 == itemLinear
                trd = self.Lazim[i]
                plng = self.Ldip[i]
                name = '[L] %s' % self.Lname[i]
            elif self.nametype == 4:  # 2 == itemFault
                ddir = self.Fazim[i]
                dp = self.Fdip[i]
                strk = self.Fstrike[i]
                trd = self.Ftrend[i]
                plng = self.Fplunge[i]
                name = '[F] %s' % self.Fname[i]
            else:
                pass

            # check if DipDir or Strike or Trend
            if ddirRb:
                #~ print 'ddier'
                Azimuth = ddir
                Dip = dp
            elif strkRb:
                #~ print 'strike'
                Azimuth = strk
                Dip = dp
            elif trndRb:
                #~ print 'trend'
                Azimuth = trd
                Dip = plng

            # nothing selected or wrong kind of data choosen
            if Azimuth == []:
                raise AttributeError

    # convert azimuth to modulo 180 or modulo 360
            azimMod = []
            if r180:  #test if 180deg rose was selected
                for az in Azimuth:
                    if 90.0 < az <= 180.0:
                        azimMod.append(az + 180.0)
                    elif 180.0 <= az <= 270.0:
                        azimMod.append(az - 180.0)
                    else:
                        azimMod.append(az)
            else:
                azimMod = Azimuth

    # calculate mean direction and circular standar deviation
    # from Fisher 1993, Statistical Analyis of circular data, p.32-33
            ndata = len(azimMod)
            cosTheta = [np.cos(np.radians(az)) for az in azimMod]
            sinTheta = [np.sin(np.radians(az)) for az in azimMod]
            C = np.sum(cosTheta)
            S = np.sum(sinTheta)
            R = np.sqrt(C * C + S * S)
            Rbar = R / ndata
            V = 1.0 - Rbar

            ThetaBar = np.arctan2(C, S)
            ThetaBarDeg = np.degrees(ThetaBar)

            if 0.0 <= ThetaBarDeg < 90.0:
                ThetaBarDeg = -(ThetaBarDeg - 90.0)
            elif 90.0 <= ThetaBarDeg <= 180.0:
                ThetaBarDeg = 540.0 + (-ThetaBarDeg - 90.0)
            else:
                ThetaBarDeg = -ThetaBarDeg + 90.0

    # assuming a unimodal Von Mises distribution..
    # from Fisher 1993, Statistical Analyis of circular data, p.88-89

    # if data does not follows a unimodal distribution (or has only one value), skip

            plotConfidence = True
            try:
                if Rbar < 0.53:
                    khatml = 2.0 * Rbar + (Rbar**3.0) + (5 * (Rbar**5.0) / 6.0)
                elif 0.53 <= Rbar <= 0.85:
                    khatml = -0.4 + 1.39 * Rbar + 0.43 / V
                else:  # Rbar > 0.85:
                    khatml = 1.0 / (Rbar**3.0 - 4.0 * (Rbar**2.0) + 3.0 * Rbar)

                if khatml < 2.0:
                    stuff = [khatml - 2.0 * ((ndata * khatml)**-1.0), 0.0]
                    khat = np.max(stuff)
                else:  #khat_ml => 2
                    khat = ((ndata - 1.0)**3.0) * khatml / (ndata**3.0 + ndata)

                sigma_vm = 1.0 / np.sqrt(ndata * Rbar * khat)
                confidenceUp = np.degrees(ThetaBar +
                                          np.arcsin(1.9604 * sigma_vm))
                confidenceDw = np.degrees(ThetaBar -
                                          np.arcsin(1.9604 * sigma_vm))
                confidence = np.degrees(np.arcsin(1.9604 * sigma_vm))
            except:
                plotConfidence = False
                pass

            if np.isnan(confidence):
                plotConfidence = False

    # convert azimuths from compass to polar
            azimPolar = []
            for az in azimMod:
                ang = 360.0 - az + 90.0
                if ang >= 360.0:
                    ang = ang - 360.0
                azimPolar.append(ang)

    # bins for the histogram
            nbins = np.arange(0., 360.1, petal)

            # test if weighted rose diagram was selected
            if weighted:
                rose_hist = np.histogram(azimPolar, nbins,
                                         weights=Dip)  #,normed=True,new=True)
                weights_sum = sum(Dip)
                petal_perc = [i * 100.0 / weights_sum for i in rose_hist[0]]
            else:
                rose_hist = np.histogram(azimPolar, nbins)  #,new=True)
                petal_perc = [i * 100.0 / len(azimPolar) for i in rose_hist[0]]

            petal_mid = [i + petal / 2 for i in nbins]
            petal_dens = [i / outer_circ for i in petal_perc]
            petal_max = max(petal_dens) * outer_circ

            # draws the petals
            for j in range(len(petal_dens)):

                x = []
                y = []
                #define limits of petal
                start = np.radians(petal_mid[j] + petal / 2)
                stop = np.radians(petal_mid[j] - petal / 2)

                #start drawing the petals (triangles: x0,y0 -> x2,y2 -> x3,y3 -> x0,y0)
                x.append(0)
                y.append(0)

                x2 = petal_dens[j] * np.cos(start)
                y2 = petal_dens[j] * np.sin(start)

                x.append(x2)
                y.append(y2)

                x3 = petal_dens[j] * np.cos(stop)
                y3 = petal_dens[j] * np.sin(stop)

                x.append(x3)
                y.append(y3)
                x.append(0)
                y.append(0)

                xy = np.array([x, y])  #convert lists to numpy array
                xy2 = xy.transpose(
                )  # transpose array from shape (2,4) to shape (4,2)

                l_petal = Polygon(xy2, fc=fillcolor, ec=edgecolor)

                axes.add_patch(l_petal)

    # draws the circle (or half-circle), and adds decorations (tick marks, rings, etc)
            if r360:  #full-circle rose

                x_cross = [0, 1, 0, -1, 0]
                y_cross = [0, 0, 1, 0, -1]
                axes.plot(x_cross, y_cross, 'k+', markersize=8)
                circ = Circle((0, 0),
                              radius=1,
                              edgecolor='black',
                              facecolor='none',
                              clip_box='None',
                              zorder=0)
                axes.add_patch(circ)
                axes.text(0.01,
                          1.025,
                          'N',
                          family='sans-serif',
                          size=fontsize,
                          horizontalalignment='center')
                axes.text(1.05,
                          0,
                          '%d %%' % outer_circ,
                          family='sans-serif',
                          size=fontsize,
                          verticalalignment='center')
                axes.text(-1.05,
                          0,
                          '%d %%' % outer_circ,
                          family='sans-serif',
                          size=fontsize,
                          verticalalignment='center',
                          horizontalalignment='right')

                for i in np.arange(0.0, 1.0, ring_steps):
                    ring = Circle((0, 0),
                                  radius=i,
                                  fc='none',
                                  ec=grid_col,
                                  lw=grid_width,
                                  zorder=0)
                    axes.add_patch(ring)

                for i in np.arange(0.0, 90.0, diagonals):
                    diag = Line2D(
                        (np.sin(np.radians(i)), np.sin(np.radians(i + 180))),
                        (np.cos(np.radians(i)), np.cos(np.radians(i + 180))),
                        c=grid_col,
                        lw=grid_width,
                        zorder=0)
                    axes.add_line(diag)

                for i in np.arange(90.0, 180.0, diagonals):
                    diag = Line2D(
                        (np.sin(np.radians(i)), np.sin(np.radians(i + 180))),
                        (np.cos(np.radians(i)), np.cos(np.radians(i + 180))),
                        c=grid_col,
                        lw=grid_width,
                        zorder=0)
                    axes.add_line(diag)

            # some texts..
                axes.text(-1.22,
                          0.95,
                          '%s' % self.Name,
                          family='sans-serif',
                          size=fontsize,
                          horizontalalignment='left')
                axes.text(-1.22,
                          0.85,
                          'n = %d' % len(azimPolar),
                          family='sans-serif',
                          size=fontsize,
                          horizontalalignment='left')
                axes.text(-1.22,
                          0.77,
                          'max = %.2f %%' % petal_max,
                          family='sans-serif',
                          size=fontsize,
                          horizontalalignment='left')
                if weighted:
                    axes.text(-1.22,
                              0.67,
                              '(weighted)',
                              family='sans-serif',
                              size=fontsize,
                              horizontalalignment='left')
                else:
                    axes.text(-1.22,
                              0.67,
                              '(frequency)',
                              family='sans-serif',
                              size=fontsize,
                              horizontalalignment='left')

                axes.text(0.7,
                          0.95,
                          u'Mean dir.: %3.1f°' % ThetaBarDeg,
                          family='sans-serif',
                          size=fontsize,
                          horizontalalignment='left')
                if plotConfidence:
                    axes.text(0.7,
                              0.87,
                              u'95 %% conf.: ± %3.1f°' % confidence,
                              family='sans-serif',
                              size=fontsize,
                              horizontalalignment='left')

            # marks for means direction and confidence interval
                if showMean:
                    if plotConfidence:
                        confcirc = Arc((0, 0),
                                       width=2.08,
                                       height=2.08,
                                       angle=0.0,
                                       theta1=confidenceDw,
                                       theta2=confidenceUp,
                                       ec=meancolor,
                                       lw=meanwidth,
                                       fill=None,
                                       zorder=0)
                        axes.add_patch(confcirc)

                    x0 = np.cos(ThetaBar) + np.cos(ThetaBar) * 0.11
                    x1 = np.cos(ThetaBar) + np.cos(ThetaBar) * 0.065
                    y0 = np.sin(ThetaBar) + np.sin(ThetaBar) * 0.11
                    y1 = np.sin(ThetaBar) + np.sin(ThetaBar) * 0.065
                    lin = Line2D((x0, x1), (y0, y1), lw=meanwidth, c=meancolor)
                    axes.add_line(lin)

                self.plotaxes2.set_xlim(-1.3, 1.3)
                self.plotaxes2.set_ylim(-1.15, 1.15)

                self.roseCanvas.draw()

            else:  #half-circle rose

                x_cross = [0, 1, 0, -1]
                y_cross = [0, 0, 1, 0]
                axes.plot(x_cross, y_cross, 'k+', markersize=8)
                circ = Arc((0, 0),
                           width=2,
                           height=2,
                           angle=0.0,
                           theta1=0.0,
                           theta2=180.0,
                           ec=None,
                           fill=None,
                           zorder=0)
                axes.add_patch(circ)
                axes.text(0.01,
                          1.025,
                          'N',
                          family='sans-serif',
                          size=fontsize,
                          horizontalalignment='center')
                axes.text(1.05,
                          0,
                          '%d %%' % outer_circ,
                          family='sans-serif',
                          size=fontsize,
                          verticalalignment='center')
                axes.text(-1.05,
                          0,
                          '%d %%' % outer_circ,
                          family='sans-serif',
                          size=fontsize,
                          verticalalignment='center',
                          horizontalalignment='right')

                for i in np.arange(0.0, 1.0, ring_steps):
                    ring = Arc((0, 0),
                               width=i * 2,
                               height=i * 2,
                               angle=0.0,
                               theta1=0.0,
                               theta2=180.0,
                               ec=grid_col,
                               fill=None,
                               lw=grid_width,
                               zorder=0)
                    axes.add_patch(ring)

                for i in np.arange(0.0, 90.1, diagonals):
                    diag = Line2D((0, np.sin(np.radians(i))),
                                  (0, np.cos(np.radians(i))),
                                  c=grid_col,
                                  lw=grid_width,
                                  zorder=0)
                    axes.add_line(diag)

                for i in np.arange(270.0, 360.0, diagonals):
                    diag = Line2D((0, np.sin(np.radians(i))),
                                  (0, np.cos(np.radians(i))),
                                  c=grid_col,
                                  lw=grid_width,
                                  zorder=0)
                    axes.add_line(diag)

            # some texts..
                axes.text(-1.22,
                          0.95,
                          '%s' % self.Name,
                          family='sans-serif',
                          size=fontsize,
                          horizontalalignment='left')
                axes.text(-1.22,
                          0.85,
                          'n = %d' % len(azimPolar),
                          family='sans-serif',
                          size=fontsize,
                          horizontalalignment='left')
                axes.text(-1.22,
                          0.77,
                          'max = %.2f %%' % petal_max,
                          family='sans-serif',
                          size=fontsize,
                          horizontalalignment='left')
                if weighted:
                    axes.text(-1.22,
                              0.67,
                              '(weighted)',
                              family='sans-serif',
                              size=fontsize,
                              horizontalalignment='left')
                else:
                    axes.text(-1.22,
                              0.67,
                              '(frequency)',
                              family='sans-serif',
                              size=fontsize,
                              horizontalalignment='left')

                axes.text(0.7,
                          0.95,
                          u'Mean dir.: %3.1f°' % ThetaBarDeg,
                          family='sans-serif',
                          size=fontsize,
                          horizontalalignment='left')
                if plotConfidence:
                    axes.text(0.7,
                              0.87,
                              u'95 %% conf.: ± %3.1f°' % confidence,
                              family='sans-serif',
                              size=fontsize,
                              horizontalalignment='left')

            # marks for means direction and confidence interval
                if showMean:
                    if plotConfidence:
                        confcirc = Arc((0, 0),
                                       width=2.08,
                                       height=2.08,
                                       angle=0.0,
                                       theta1=confidenceDw,
                                       theta2=confidenceUp,
                                       ec=meancolor,
                                       lw=meanwidth,
                                       fill=None,
                                       zorder=0)
                        axes.add_patch(confcirc)

                    x0 = np.cos(ThetaBar) + np.cos(ThetaBar) * 0.11
                    x1 = np.cos(ThetaBar) + np.cos(ThetaBar) * 0.065
                    y0 = np.sin(ThetaBar) + np.sin(ThetaBar) * 0.11
                    y1 = np.sin(ThetaBar) + np.sin(ThetaBar) * 0.065
                    lin = Line2D((x0, x1), (y0, y1), lw=meanwidth, c=meancolor)
                    axes.add_line(lin)

                self.plotaxes2.set_xlim(-1.3, 1.3)
                self.plotaxes2.set_ylim(-0.05, 1.15)

                self.roseCanvas.draw()

            self.mainframe.sb.SetStatusText(
                'Rose diagram plotted with petals of %d degrees' % petal)

#~ # this is from the 'try' right after 'def DrawRose'
        except AttributeError:
            dlg = wx.MessageDialog(
                None,
                'No file(s) selected (highlighted).\n\nOr maybe you are trying to make a diagram\nfor the wrong kind of data (like "trend" for planar data)',
                'Oooops!', wx.OK | wx.ICON_ERROR)
            dlg.ShowModal()
            dlg.Destroy()
            pass
Ejemplo n.º 33
0
        def transform_path_non_affine(self, path):
            vertices = path.vertices
            codes = path.codes
            steps = path._interpolation_steps

            x, y = np.array(list(zip(*vertices)))

            if len(vertices) > 1 and not isinstance(steps, int):
                if steps == 'inf_circle':
                    z = x + y * 1j
                    new_vertices = []
                    new_codes = []

                    for i in range(len(z) - 1):
                        az = self._axes._moebius_z(0.5 * (z[i] + z[i+1]))
                        zz = self._axes._moebius_z(z[i:i+2])
                        ax, ay = az.real, az.imag
                        bz, cz = zz
                        bx, cx = zz.real - ax
                        by, cy = zz.imag - ay

                        k = 2 * (bx * cy - by * cx)
                        xm = (cy * (bx ** 2 + by ** 2) - by * (cx ** 2 + cy ** 2)) / k + ax
                        ym = (bx * (cx ** 2 + cy ** 2) - cx * (bx ** 2 + by ** 2)) / k + ay

                        zm = xm + ym * 1j
                        d = 2 * abs(zm - az)

                        ang0 = np.angle(bz - zm, deg=True) % 360
                        ang1 = np.angle(cz - zm, deg=True) % 360

                        reverse = ang0 > ang1
                        if reverse:
                            ang0, ang1 = ang1, ang0

                        arc = Arc([xm, ym], d, d, theta1=ang0, theta2=ang1, transform=self._axes.transMoebius)
                        arc_path = arc.get_patch_transform().transform_path(arc.get_path())

                        if reverse:
                            new_vertices.append(arc_path.vertices[::-1])
                        else:
                            new_vertices.append(arc_path.vertices)

                        new_codes.append(arc_path.codes)

                    new_vertices = np.concatenate(new_vertices)
                    new_codes = np.concatenate(new_codes)
                elif steps == 'center_circle':
                    points = self._axes._get_key("path.default_interpolation")

                    z = self._axes._moebius_z(x + y * 1j)

                    ang0, ang1 = np.angle(z[0:2]) % TWO_PI
                    ccw = (ang1 - ang0) % TWO_PI < np.pi

                    ix, iy = [np.real(z[0])], [np.imag(z[0])]
                    new_codes = [Path.MOVETO]

                    for i in range(len(z) - 1):
                        zz = z[i:i + 2]

                        r0, r1 = np.abs(zz)
                        ang0, ang1 = np.angle(zz) % TWO_PI

                        if ccw:
                            if ang0 > ang1:
                                ang1 += TWO_PI
                        else:
                            if ang1 > ang0:
                                ang0 += TWO_PI

                        r = np.linspace(r0, r1, points)[1:]
                        ang = np.linspace(ang0, ang1, points)[1:]

                        ix += list(np.cos(ang) * r)
                        iy += list(np.sin(ang) * r)

                        new_codes += (points - 1) * [Path.LINETO]

                    new_vertices = list(zip(ix, iy))
                else:
                    raise ValueError("Interpolation must be either an integer, 'inf_circle' or 'center_circle'")
            else:
                if steps == 0:
                    steps = self._axes._get_key("path.default_interpolation")

                ix, iy = ([x[0:1]], [y[0:1]])
                for i in range(len(x) - 1):
                    x0, x1 = x[i:i + 2]
                    y0, y1 = y[i:i + 2]


                    tx = self._axes.real_interp1d([x0, x1], steps)[1:]
                    if abs(x0 - x1) > EPSILON:
                        ty = y0 + (tx - x0) * (y1 - y0) / (x1 - x0)
                    else:
                        ty = self._axes.imag_interp1d([y0, y1], steps)[1:]

                    ix.append(tx)
                    iy.append(ty)

                if codes is not None:
                    new_codes = Path.LINETO * np.ones((len(codes) - 1) * steps + 1)
                    new_codes[0::steps] = codes
                else:
                    new_codes = None

                new_vertices = self.transform_non_affine(list(zip(np.concatenate(ix), np.concatenate(iy))))
                new_codes = codes

            return Path(new_vertices, new_codes, 1)