def _add_north_east(self, fig): if self.obs_mode == 'LIFU': origin_x = 0.66 origin_y = 0.09 elif self.obs_mode == 'mIFU': origin_x = 0.81 origin_y = 0.07 lenght = 0.05 width = 0.001 head_width = 3 * width head_length = 1.5 * head_width text_factor = 1.2 north_arrow = FancyArrow( origin_x, origin_y, 0, lenght, width=width, head_width=head_width, head_length=head_length, transform=fig.transFigure, figure=fig) east_arrow = FancyArrow( origin_x, origin_y, -self.figaspect * lenght, 0, width=(width / self.figaspect), head_width=(head_width / self.figaspect), head_length=(head_length * self.figaspect), transform=fig.transFigure, figure=fig) fig.lines.extend([north_arrow, east_arrow]) fig.text(origin_x, origin_y + text_factor * lenght, 'N', ha='right') fig.text(origin_x - text_factor * self.figaspect * lenght, origin_y, 'E', ha='right')
def show(self): """Plot out the trial.""" ax = plt.axes(xlim=(-30, 300), ylim=(-30, 300)) line, = ax.plot([], []) ax.add_patch(FancyArrow(0, 0, 300, 0, color='black')) ax.add_patch(FancyArrow(0, 0, 0, 300, color='black')) ax.add_patch(FancyArrow(270, 270, 0, -300, color='black')) ax.add_patch(FancyArrow(270, 270, -300, 0, color='black')) # add targets for target in self.env.targets: ax.add_patch(Circle(target[0], target[1], color='gray')) for a in self.env.agents: for i in range(self.iteration): ax.add_patch(Circle(a.loc_data[-i], a.r, color=a.color)) ax.add_patch( FancyArrow(a.loc_data[-i][0], a.loc_data[-i][1], find_dx(a.loc_data[-i][0], a.ang_data[-i], a.r), find_dy(a.loc_data[-i][1], a.ang_data[-i], a.r), color='black', length_includes_head=True, head_width=0.2)) ax.set_aspect('equal') ax.figure.set_size_inches(6, 6)
def main(): R = np.array([[0, 0], [1, 0], [0, 2], [1.5, 2]]) P = np.array([[0, 0], [1, 0], [0, 1], [1, 1]]) Q, r, _ = convex_solution(R, P) ax: plt.Axes fig, ax = plt.subplots() R_scat = ax.scatter(*R.T, c="black") Q_scat = ax.scatter(*Q.T, c="green") vecs = Q - R arrows = [ FancyArrow(0, 0, *vec, color="black", head_width=0.02) for vec in vecs ] arrows.append( FancyArrow(0, 0, *(vecs[0] + vecs[1]), color="green", head_width=0.02)) for arrow in arrows: ax.add_patch(arrow) for p in P[2:]: tri = Triangle(PlanarTriangle([*P[:2], p]).angles) c = tri.trivial_replication_point(*P[:2]) ax.scatter(*c, color="blue") ax.axis("square") plt.show()
def drawNode(node, prv): if node.code == 'nivvie': return prev = prv + 0 val = node.vals[0] bot = prev for child in node.children: drawNode(child, prev) prev += child.vals[0] if (val != 0) and node.visible and node.code != 'root': r, g, b = node.color a = FancyArrow(number[0] + barwidth / 2, bot, 0, val, width=barwidth, fc=(r / 255, g / 255, b / 255), linewidth=0.5, edgecolor='black', label=node.desc, picker=True, length_includes_head=True, head_width=barwidth, head_length=abs(val / 15)) a.top = bot + max(0, val) a.absci = number[0] + 0 # a = Rectangle((number[0], bot), barwidth, val, fc = node.color, linewidth = 0.5, edgecolor = 'black', label = node.desc, picker = True) a.value = round(val) patches.append(a) codes.append(node.code) shortnames.append(node.shortname) number[0] += 1
def drawNode(node, prv): prev = prv + 0 val = node.vals[0] bot = prev for child in node.children: drawNode(child, prev) prev += child.vals[0] if (val != 0) and node.visible: r, g, b = node.color arrow = FancyArrow( number[0] + barwidth / 2, bot, 0, val, width = barwidth, fc = (r / 255, g / 255, b / 255), linewidth = 0.5, edgecolor = 'black', label = node.desc, picker = True, length_includes_head = True, head_width = barwidth, head_length = abs(val / 15), ) arrow.top = bot + max(0, val) arrow.absci = number[0] + 0 # a = Rectangle((number[0], bot), barwidth, val, fc = node.color, linewidth = 0.5, edgecolor = 'black', label = node.desc, picker = True) arrow.value = round(val) patches.append(arrow) codes.append(node.code) shortnames.append(node.shortname) number[0] += 1
def plot_vectors(axes, image_geo_extents, vector_file, user_scale_factor): with open(vector_file) as json_file: origins_vectors = json.load(json_file) origins_vectors_numpy = np.asarray(origins_vectors) plot_width_in_pixels = axes.get_window_extent().width plot_width_in_ground_units = image_geo_extents[1] - image_geo_extents[0] pixels_per_ground_unit = plot_width_in_pixels / plot_width_in_ground_units ground_units_per_pixel = plot_width_in_ground_units / plot_width_in_pixels vector_lengths_ground = np.linalg.norm(origins_vectors_numpy[:, 2:], axis=1) vector_lengths_pixels = vector_lengths_ground * pixels_per_ground_unit arrow_scale_factor = ( 30 * ground_units_per_pixel) / np.median(vector_lengths_ground) arrow_head_scale_factor = 8 * ground_units_per_pixel for i in range(len(origins_vectors)): arrow = FancyArrow( origins_vectors[i][0], origins_vectors[i][1], origins_vectors[i][2] * arrow_scale_factor * user_scale_factor, -origins_vectors[i][3] * arrow_scale_factor * user_scale_factor, # Negative sign converts from dV (positive down) to dY (positive up) length_includes_head=True, head_width=arrow_head_scale_factor, overhang=0.8, fc='yellow', ec='yellow') axes.add_artist(arrow) geo_height = image_geo_extents[3] - image_geo_extents[2] legend_background = Rectangle((image_geo_extents[0] + geo_height / 50, image_geo_extents[2] + geo_height / 50), geo_height / 7, geo_height / 7, fc='silver', clip_on=False, alpha=0.75) axes.add_artist(legend_background) plt.text(image_geo_extents[0] + geo_height / 50 + geo_height / 14, image_geo_extents[2] + geo_height / 7, '{0:.3f}'.format( np.median(vector_lengths_ground) / user_scale_factor), horizontalalignment='center', verticalalignment='top') arrow = FancyArrow(image_geo_extents[0] + geo_height / 50 + (geo_height / 7 - 30 * ground_units_per_pixel) / 2, image_geo_extents[2] + geo_height / 14, 30 * ground_units_per_pixel, 0, length_includes_head=True, head_width=arrow_head_scale_factor, overhang=0.8, fc='yellow', ec='yellow') axes.add_artist(arrow)
def show(self): """Show network.""" ax = plt.axes(xlim=(0, max(self.i, self.h, self.o) * 25 + 25), ylim=(0, 200)) line, = ax.plot([], []) ax.set_aspect('equal') ax.figure.set_size_inches(5, 2) i_nodes = [] h_nodes = [] o_nodes = [] x = 25 y = 150 for t in range(self.i): ax.add_patch(Circle((x, y), 10, color='green')) i_nodes.append((x, y)) x += 25 y -= 50 x = (max(self.i, self.h, self.o) - self.h) / 2 * 25 + 25 for t in range(self.h): ax.add_patch(Circle((x, y), 10, color='purple')) h_nodes.append((x, y)) x += 25 y -= 50 x = (max(self.i, self.h, self.o) - self.o) / 2 * 25 + 25 for t in range(self.o): ax.add_patch(Circle((x, y), 10, color='blue')) o_nodes.append((x, y)) x += 25 for t in i_nodes: for j in h_nodes: ax.add_patch( FancyArrow(t[0], t[1], j[0] - t[0], j[1] - t[1], width=0.00000001, color='black', length_includes_head=True, head_width=3)) for t in h_nodes: for j in o_nodes: ax.add_patch( FancyArrow(t[0], t[1], j[0] - t[0], j[1] - t[1], width=0.00000001, color='black', length_includes_head=True, head_width=3))
def draw_infinite(state1=0, state2=1, text=0.1): radius = 0.5 x1 = state1 * delta + radius diff_state = abs(state2 - state1) x2 = delta * diff_state - 2 * radius y = 0 ellipse = Arc([x1 + x2 / 2, y], x2, almost_zero, angle=0, theta1=0, theta2=180.0, color='k', linewidth='1', ls='dotted') arrow2 = FancyArrow(x1 + x2 / 2 - 0.01, 0, 0.01, 0, width=arrow_width, length_includes_head=False, head_width=None, head_length=None, shape='full', overhang=0, head_starts_at_zero=False, color='k') plt.gca().add_patch(ellipse) plt.gca().add_patch(arrow2) y = 0 ellipse = Arc([1, y], x2, almost_zero, angle=0, theta1=0, theta2=180.0, color='k', linewidth='1', ls='dotted') plt.gca().add_patch(ellipse) arrow2 = FancyArrow(1 - 0.01, 0, 0.01, 0, width=arrow_width, length_includes_head=False, head_width=None, head_length=None, shape='full', overhang=0, head_starts_at_zero=False, color='k') plt.gca().add_patch(arrow2)
def directed_flow(coords, flow, color, area_factor=1, cmap=None): """ Helper function to generate arrows from flow data. """ # this funtion is used for diplaying arrows representing the network flow data = pd.DataFrame({ 'arrowsize': flow.abs().pipe(np.sqrt).clip(lower=1e-8), 'direction': np.sign(flow), 'linelength': (np.sqrt((coords.x1 - coords.x2)**2. + (coords.y1 - coords.y2)**2)) }) data = data.join(coords) if area_factor: data['arrowsize'] = data['arrowsize'].mul(area_factor) data['arrowtolarge'] = (1.5 * data.arrowsize > data.linelength) # swap coords for negativ directions data.loc[data.direction == -1., ['x1', 'x2', 'y1', 'y2']] = \ data.loc[data.direction == -1., ['x2', 'x1', 'y2', 'y1']].values if ((data.linelength > 0.) & (~data.arrowtolarge)).any(): data['arrows'] = ( data[(data.linelength > 0.) & (~data.arrowtolarge)].apply( lambda ds: FancyArrow(ds.x1, ds.y1, 0.6 * (ds.x2 - ds.x1) - ds.arrowsize * 0.75 * (ds.x2 - ds.x1) / ds.linelength, 0.6 * (ds.y2 - ds.y1) - ds.arrowsize * 0.75 * (ds.y2 - ds.y1) / ds.linelength, head_width=ds.arrowsize), axis=1)) data.loc[(data.linelength > 0.) & (data.arrowtolarge), 'arrows'] = \ (data[(data.linelength > 0.) & (data.arrowtolarge)] .apply(lambda ds: FancyArrow(ds.x1, ds.y1, 0.001*(ds.x2 - ds.x1), 0.001*(ds.y2 - ds.y1), head_width=ds.arrowsize), axis=1)) data = data.dropna(subset=['arrows']) arrowcol = PatchCollection(data.arrows, color=color, edgecolors='k', linewidths=0., zorder=4, alpha=1) return arrowcol
def draw_promoter(feature, x, y, width, height, figure, loc_index, style_dict): from matplotlib.patches import Rectangle from matplotlib.patches import Wedge from matplotlib.patches import FancyArrow from matplotlib.text import Text base_width = 4 head_width = 8 curve_radius = 10 y_center = y + height/2 y_curve_max = y + height - head_width/2 + base_width/2 y_curve_min = y_curve_max - curve_radius y_tip = y + height - head_width/2 vertical = Rectangle((x, y_center), base_width, y_curve_min-y_center, color="black", linewidth=0) figure.patches.append(vertical) curve = Wedge(center=(x+curve_radius, y_curve_min), r=curve_radius, theta1=90, theta2=180, width=base_width, color="black", linewidth=0) figure.patches.append(curve) horizontal = FancyArrow( x+curve_radius, y_tip, dx=width-curve_radius, dy=0, width=base_width, head_width=head_width, head_length=head_width, length_includes_head=True, color="black", linewidth=0 ) figure.patches.append(horizontal) if "note" in feature.qual: text = Text(x + width/2, y + height/4, feature.qual["note"], color="black", ha="center", va="center", size=9, figure=figure) figure.texts.append(text)
def showOccl(self, occl, img): """ Show occlusion data """ img = self.getImgs(img)[0] fig, ax = plt.subplots(1) if img is not None and not self.waiting: self.showImg(img, wait=True, ax=ax) bounds = np.zeros(occl['imsize']) for i in range(occl['ne']): # ne = "number of edges" pixel_indices = occl['edges']['indices'][i] num_pixels = len(pixel_indices) pixel_coords = np.unravel_index(pixel_indices, occl['imsize'], order='F') edgelabel = occl['edges']['edgelabel'][i] bounds[pixel_coords] = 1 for j in range(num_pixels - OCCLUSION_ARROW_DISTANCE): if j % OCCLUSION_ARROW_DISTANCE == 0: # draw arrow a = [pixel_coords[0][j], pixel_coords[1][j]] b = [ pixel_coords[0][j + OCCLUSION_ARROW_DISTANCE], pixel_coords[1][j + OCCLUSION_ARROW_DISTANCE] ] # midpoint mid = (np.array(a) + np.array(b)) / 2 d0 = b[0] - a[0] d1 = b[1] - a[1] # point towards b if edgelabel is 1, # else (edgelabel is 2), point away if edgelabel != 1: d0 *= -1 d1 *= -1 # normalize direction vector norm = np.sqrt(d0 * d0 + d1 * d1) d0 /= norm d1 /= norm ax.add_patch( FancyArrow(mid[1], mid[0], d0, -d1, width=0.0, head_width=2.5, head_length=5.0, facecolor='white', edgecolor='none')) # show mask self.showMask(bounds, img)
def _draw_sheet(feature, x, y, width, height, figure, loc_index, style_dict): from matplotlib.patches import FancyArrow head_height = 0.8 * height tail_height = 0.5 * height head_width = 0.4 * height tail_x = x arrow_y = y + height / 2 dx = width dy = 0 if head_width > width: # If fteaure is to short, draw only narrowed head head_width = width loc = feature.locs[loc_index] if loc.defect & seq.Location.Defect.MISS_RIGHT: head_width = 0 head_height = tail_height arrow = FancyArrow(tail_x, arrow_y, dx, dy, width=tail_height, head_width=head_height, head_length=head_width, length_includes_head=True, color=biotite.colors["orange"], linewidth=0) figure.patches.append(arrow)
def draw_edge(sheet, coords, ax, **draw_spec_kw): """ """ draw_spec = sheet_spec()["edge"] draw_spec.update(**draw_spec_kw) x, y = coords dx, dy = ("d" + c for c in coords) app_length = np.hypot(sheet.edge_df[dx], sheet.edge_df[dy]) patches = [] arrow_specs, collections_specs = parse_edge_specs(draw_spec, sheet) for idx, edge in sheet.edge_df[app_length > 1e-6].iterrows(): srce = int(edge["srce"]) arrow = FancyArrow( sheet.vert_df.loc[srce, x], sheet.vert_df.loc[srce, y], sheet.edge_df.loc[idx, dx], sheet.edge_df.loc[idx, dy], **arrow_specs, ) patches.append(arrow) ax.add_collection(PatchCollection(patches, False, **collections_specs)) return ax
def draw_self_transition(state=0, text='0.55'): x_pos = state * delta y_pos = 0.7 height = 0.60 width = 0.55 ellipse = Arc([x_pos, y_pos], width, height, angle=0, theta1=-50, theta2=230.0, color='k', linewidth='1') plt.gca().add_patch(ellipse) arrow2 = FancyArrow(x_pos - 0.01, y_pos + height / 2, 0.01, -0.002, width=arrow_width, length_includes_head=False, head_width=None, head_length=None, shape='full', overhang=0, head_starts_at_zero=False, color='k') plt.gca().add_patch(arrow2) plt.text(x_pos, y_pos + 1.1 * height / 2, text, fontsize=12, horizontalalignment='center', verticalalignment='bottom')
def plot(src: PlanarTriangle, dst: PlanarTriangle, color="black") -> Tuple[plt.Figure, plt.Axes]: fig: plt.Figure ax: plt.Axes fig, ax = plt.subplots() ax.set_xlim([0.1, .9]) ax.set_ylim([0.1, .8]) ax.axis("square") ax.scatter(*(src.points.T), c="black") dst.plot(fig, ax, color=color) patches = PatchCollection([ FancyArrow(*s, *(d - s), length_includes_head=True, width=0.005, head_width=0.025, color="k") for s, d in zip(src.points, dst.points) ], edgecolors="k", facecolors="k") ax.add_collection(patches) plt.axis("off") return fig, ax
def render(self, ctx): """ Render the edge in the given axes. :param ctx: The :class:`_rendering_context` object. """ ax = ctx.ax() plot_params = self.plot_params plot_params["linewidth"] = _pop_multiple(plot_params, ctx.line_width, "lw", "linewidth") plot_params["linestyle"] = plot_params.get("linestyle", "-") # Add edge annotation. if self.label is not None: x, y, dx, dy = self._get_coords(ctx) ax.annotate( self.label, [x + 0.5 * dx + self.xoffset, y + 0.5 * dy + self.yoffset], xycoords="data", xytext=[0, 3], textcoords="offset points", ha="center", va="center", **self.label_params ) if self.directed: plot_params["ec"] = _pop_multiple(plot_params, "k", "ec", "edgecolor") plot_params["fc"] = _pop_multiple(plot_params, "k", "fc", "facecolor") plot_params["head_length"] = plot_params.get("head_length", 0.25) plot_params["head_width"] = plot_params.get("head_width", 0.1) # Build an arrow. args = self._get_coords(ctx) # zero lengh arrow produce error if not (args[2] == 0.0 and args[3] == 0.0): ar = FancyArrow( *self._get_coords(ctx), width=0, length_includes_head=True, **plot_params ) # Add the arrow to the axes. ax.add_artist(ar) return ar else: print(args[2], args[3]) else: plot_params["color"] = plot_params.get("color", "k") # Get the right coordinates. x, y, dx, dy = self._get_coords(ctx) # Plot the line. line = ax.plot([x, x + dx], [y, y + dy], **plot_params) return line
def draw_token(cls, token, r, c, ax, height, width, token_scale=1.0): if token == EMPTY: return None if 'arrow' in token: edge_color = '#888888' face_color = '#AAAAAA' drawing = RegularPolygon((c + 0.5, (height - 1 - r) + 0.5), numVertices=4, radius=0.5 * np.sqrt(2), orientation=np.pi / 4, ec=edge_color, fc=face_color) ax.add_patch(drawing) if token == LEFT_ARROW: arrow_drawing = FancyArrow(c + 0.75, height - 1 - r + 0.5, -0.25, 0.0, width=0.1, fc='green', head_length=0.2) ax.add_patch(arrow_drawing) elif token == RIGHT_ARROW: arrow_drawing = FancyArrow(c + 0.25, height - 1 - r + 0.5, 0.25, 0.0, width=0.1, fc='green', head_length=0.2) ax.add_patch(arrow_drawing) else: im = TOKEN_IMAGES[token] oi = OffsetImage(im, zoom=cls.fig_scale * (token_scale / max(height, width)**0.5)) box = AnnotationBbox(oi, (c + 0.5, (height - 1 - r) + 0.5), frameon=False) ax.add_artist(box) return box
def draw(self, tail_coords, head_coords, node_radius, **kwargs): self.edge_width = process_width(self.edge_width, kwargs) self.head_width_to_edge_width = process_head_width_to_width( self.head_width_to_edge_width, kwargs) self.head_length_to_head_width = process_head_length_to_head_width( self.head_length_to_head_width, kwargs) self.overhang = process_overhang(self.overhang, kwargs) self.alpha = process_alpha(self.alpha, kwargs) self.face_color = process_face_color(self.face_color, kwargs) if self.angle == None: self.get_angle(tail_coords, head_coords) node_delta = Point(node_radius * cos(self._angle_radians), node_radius * sin(self._angle_radians)) if tail_coords.draw_bool: tail_delta = Point(node_delta.x, node_delta.y) else: tail_delta = Point() head_delta = Point(-1.0 * node_delta.x, -1.0 * node_delta.y) if self.directional: head_width = self.head_width_to_edge_width * self.edge_width head_length = self.head_length_to_head_width * head_width if not head_coords.draw_bool: head_delta = Point() else: head_width = 0.0 head_length = 0.0 if not head_coords.draw_bool: head_delta = Point( 0.5 * self.edge_width * cos(self._angle_radians), 0.5 * self.edge_width * sin(self._angle_radians)) tail_coords = tail_coords + tail_delta head_coords = head_coords + head_delta delta = head_coords - tail_coords if self.draw_bool: patch = FancyArrow(tail_coords.x, tail_coords.y, delta.x, delta.y, width=self.edge_width, length_includes_head=True, head_width=head_width, head_length=head_length, shape='full', overhang=self.overhang, head_starts_at_zero=False, fc=self.face_color, alpha=self.alpha) return patch else: return None
def draw_orientation(ax, centers, sizes, angles, colors, mode): if mode == 'front': length = 5 fill = False alpha = 0.6 zorder_circle = 0.5 zorder_arrow = 5 linewidth = 1.5 edgecolor = 'k' radiuses = [s / 1.2 for s in sizes] else: length = 1.3 head_width = 0.3 linewidth = 2 radiuses = [0.2] * len(centers) fill = True alpha = 1 zorder_circle = 2 zorder_arrow = 1 for idx, theta in enumerate(angles): color = colors[idx] radius = radiuses[idx] if mode == 'front': x_arr = centers[idx][0] + (length + radius) * math.cos(theta) z_arr = length + centers[idx][1] + (length + radius) * math.sin(theta) delta_x = math.cos(theta) delta_z = math.sin(theta) head_width = max(10, radiuses[idx] / 1.5) else: edgecolor = color x_arr = centers[idx][0] z_arr = centers[idx][1] delta_x = length * math.cos(theta) delta_z = -length * math.sin( theta) # keep into account kitti convention circle = Circle(centers[idx], radius=radius, color=color, fill=fill, alpha=alpha, zorder=zorder_circle) arrow = FancyArrow(x_arr, z_arr, delta_x, delta_z, head_width=head_width, edgecolor=edgecolor, facecolor=color, linewidth=linewidth, zorder=zorder_arrow) ax.add_patch(circle) ax.add_patch(arrow)
def plot(mag, bearingDeg, fname): """Make a single wind direction image.""" print(f"plotting {mag} {bearingDeg}") fig, ax = plt.subplots(figsize=(6, 6)) for rad in [0.33, 0.66, 1.0]: circle = Circle((0, 0), rad, fill=False, ec="black", color="b", alpha=0.1) ax.add_patch(circle) # Add lines for angleI in range(NUM_DIRS): theta = angleI * 2 * math.pi / NUM_DIRS x = math.cos(theta) y = math.sin(theta) plt.plot( (0, x), (0, y), color="k", alpha=0.1, ) # arrow theta = bearingDeg * math.pi / 180.0 # rotate 90° to have north be up. y = math.cos(theta) x = math.sin(theta) color = colormap(mag) # Wind directions are always reported by the bearing of the wind (i.e. where it's # coming from) # Make a length-2 arrow pointing toward where the wind is coming from. # Make bigger and different colors if the wind is extra windy. # Tail is specified reflected through the origin arrow = FancyArrow( -x, -y, 2 * x, 2 * y, color=color, width=0.05 + 0.20 * mag, length_includes_head=True, head_length=2.0, ec="black", alpha=1.00, zorder=100, ) ax.add_patch(arrow) plt.axis("equal") plt.axis("off") # plt.tight_layout() plt.margins(0) plt.savefig(fname) plt.close()
def __init__(self, ax, flowcollection, frange=2, normalized=True, scale_arrows=True, **kwargs): self.ax = ax self.flowcollection = flowcollection self.normalized = normalized self.frange = frange self.scale_arrows = scale_arrows self.MaxFlow = flowcollection.getMaxFlow() self.MinFlow = flowcollection.getMinFlow() if frange == 'all': if normalized: self.norm = kwargs.pop('norm', LogNorm(self.MinFlow/self.MaxFlow, 1, clip=True)) else: self.norm = kwargs.pop('norm', LogNorm(self.MinFlow, self.MaxFlow, clip=True)) else: if normalized: self.norm = kwargs.pop('norm', LogNorm(10**(-frange), 1, clip=True)) else: self.norm = kwargs.pop('norm', LogNorm(self.MaxFlow*10**(-frange), self.MaxFlow, clip=True)) self.cmap = cm.get_cmap(kwargs.pop('cmap', 'jet')) self.ax.axis(self.flowcollection.getBounds()) kwargs.setdefault('lw', .3) Arrows = [] Acol = [] if normalized: flows = np.vectorize(lambda f: f.flow / self.MaxFlow)(self.flowcollection.flows) else: flows = np.vectorize(lambda f: f.flow)(self.flowcollection.flows) for fl, flow in zip(flows, self.flowcollection.flows): if frange != 'all' and self.norm(fl) <= 0: continue if scale_arrows: width = .2*self.norm(fl) + 0.01 else: width = .15 st = {"ec": 'k', "width": width, "head_width": 2.5*width, "head_length": .5} nkwargs = kwargs.copy() for kv in st.items(): nkwargs.setdefault(*kv) ar = FancyArrow(flow.N0, flow.Z0, flow.dN, flow.dZ, length_includes_head=True, **nkwargs) Arrows.append(ar) Acol.append(fl) Arrows = np.array(Arrows) Acol = np.array(Acol) self.Patches = PatchCollection(Arrows, norm=self.norm, cmap=self.cmap, match_original=True) self.Patches.set_array(Acol) self.ax.add_collection(self.Patches, )
def addArrow(self, x, y, dx, dy, nh_value): arr = FancyArrow(x=x, y=y, dx=dx, dy=dy, edgecolor='y', facecolor='y', length_includes_head=True, linewidth=0.2, head_width=0.05, head_length=0.05) self.axes.add_patch(arr)
def animate(i): l.set_data(xs[i], ys[i]) ax.patches.pop() arrow = FancyArrow(xs[i], ys[i], orientation[i][0], orientation[i][1], color='r') patch = ax.add_patch(arrow)
def show(self): """Show network plot.""" ax = plt.axes(xlim=(0, max(self.i, self.h, self.o) * 25 + 100), ylim=(0, 200)) line, = ax.plot([], []) ax.set_aspect('equal') ax.figure.set_size_inches(5, 2) nodes = [] x = 25 y = 50 for t in range(self.i): ax.add_patch(Circle((x, y), 10, color='green')) nodes.append((t, x, y)) x += 25 y += 50 x = max(self.i, self.h, self.o) * 25 + 25 for t in range(self.h): ax.add_patch(Circle((x, y), 10, color='purple')) nodes.append((t + self.i, x, y)) x += 25 y += 50 x = (max(self.i, self.h, self.o) - self.o) / 2 * 25 + 25 for t in range(self.o): ax.add_patch(Circle((x, y), 10, color='blue')) nodes.append((t + self.i + self.h, x, y)) x += 25 for i in nodes: for c in self.connections.keys(): if self.connections[c]['input'] == i[0]: out = self.connections[c]['output'] j = nodes[out] color = 'black' if self.connections[c]['weight'] < 0: color = 'blue' elif self.connections[c]['weight'] > 0: color = 'red' ax.add_patch( FancyArrow(i[1], i[2], j[1] - i[1], j[2] - i[2], width=0.001, color=color, length_includes_head=True, head_width=5)) ax.set_aspect('equal') ax.figure.set_size_inches(6, 6)
def _draw_loop(self, gv, loop, size, imsize): coords = [gv.get_node(n).attr['pos'].split(',') for n in loop['nodes']] x = np.mean([float(c[0]) for c in coords]) y = np.mean([float(c[1]) for c in coords]) x = x * imsize[0] / size[0] y = imsize[1] - y * imsize[1] / size[1] head = FancyArrow(x + 15, y, 0, -1, head_width=10, color="k") arrow = Arc((x, y), 30, 30, theta1=0, theta2=270) plt.gca().add_patch(arrow) plt.gca().add_patch(head) plt.text(x - 5, y + 4, loop['type'], fontsize=8)
def plot_arrow(fig: plt.Figure, ax: plt.Axes, R: PlanarTriangle, P: Triangle, i: int, scale: bool): triv = get_triv(R, P, i) length = triv.points[2] - R.points[i] if scale: length *= P.sides[(i + 1) % 3] arrow = FancyArrow(*R.points[i], *length, length_includes_head=True, head_width=0.035, color="black") ax.add_patch(arrow)
def reddening_vector_patch(R, mag2_lim=(19, 20), color_start=0.4, **kwargs): xs = np.linspace(color_start, 10, 10000) ys = xs * R + mag2_lim[0] - xs[0] * R plt_inds = np.nonzero(ys < mag2_lim[1])[0] x = xs[plt_inds][0] y = ys[plt_inds][0] dx = xs[plt_inds][-1] - x dy = ys[plt_inds][-1] - y from matplotlib.patches import FancyArrow arr = FancyArrow(x, y, dx, dy, **kwargs) return arr
def draw_lattice(basis, showfig=False): fig, ax = plt.subplots(figsize=(3, 3)) ax.spines['top'].set_color('none') ax.spines['bottom'].set_position('zero') ax.spines['left'].set_position('zero') ax.spines['right'].set_color('none') ax.set_aspect(1) plotrange = 2 ax.set_xlim(-plotrange - 0.2, plotrange + 0.2) ax.set_ylim(-plotrange - 0.2, plotrange + 0.2) ax.tick_params(labelleft=False, labelbottom=False, labelsize=12) ax.set_xticks(np.arange(-plotrange, plotrange + 1, dtype=int)) ax.set_yticks(np.arange(-plotrange, plotrange + 1, dtype=int)) points = [] n = 4 for i, j in product(np.arange(-n, n + 1, dtype=int), repeat=2): points.append(i * basis[0] + j * basis[1]) points = np.asarray(points) print(points.shape) ax.scatter(points[:, 0], points[:, 1], color='black', s=15) arrow_kw = { 'head_width': 0.15, 'head_length': 0.2, 'width': 0.03, 'length_includes_head': True } b1 = FancyArrow(0, 0, *basis[0], **arrow_kw, color='red', zorder=3) b2 = FancyArrow(0, 0, *basis[1], **arrow_kw, color='red', zorder=3) ax.add_artist(b1) ax.add_artist(b2) fig.tight_layout() if showfig: plt.show() return fig
def render(self, ctx): """ Render the edge in the given axes. :param ctx: The :class:`_rendering_context` object. """ ax = ctx.ax() p = self.plot_params p["linewidth"] = _pop_multiple(p, ctx.line_width, "lw", "linewidth") # Add edge annotation. if "label" in self.plot_params: x, y, dx, dy = self._get_coords(ctx) ax.annotate( self.plot_params["label"], [x + 0.5 * dx + self.xoffset, y + 0.5 * dy + self.yoffset], xycoords="data", xytext=[0, 3], textcoords="offset points", ha="center", va="center") if self.directed: p["ec"] = _pop_multiple(p, "k", "ec", "edgecolor") p["fc"] = _pop_multiple(p, "k", "fc", "facecolor") p["head_length"] = p.get("head_length", 0.25) p["head_width"] = p.get("head_width", 0.1) # Build an arrow. ar = FancyArrow(*self._get_coords(ctx), width=0, length_includes_head=True, **p) # Add the arrow to the axes. ax.add_artist(ar) return ar else: p["color"] = p.get("color", "k") # Get the right coordinates. x, y, dx, dy = self._get_coords(ctx) # Plot the line. line = ax.plot([x, x + dx], [y, y + dy], **p) return line
def _draw_region_movements(self, visualizer, image_rgb, region, movements, event_count=None, arrow_size=20): ax = visualizer.output.ax x0, y0 = region.min(axis=0).astype(int) x1, y1 = region.max(axis=0).astype(int) roi = image_rgb[y0:y1, x0:x1] color = self.color_manager.get_color('region', roi) roi = Polygon(region, fill=False, color=color, linewidth=self._linewidth(visualizer)) ax.add_patch(roi) colors = {} movements = sorted(movements.items(), key=lambda x: int(x[0])) if event_count is not None: event_count = event_count.astype(str) for label, movement in movements: x0, y0 = movement.min(axis=0).astype(int) x1, y1 = movement.max(axis=0).astype(int) roi = image_rgb[y0:y1, x0:x1] color = self.color_manager.get_color(('movement', label), roi) colors[label] = color if event_count is not None: label = '%s: %s' % (label, ', '.join(event_count[label - 1])) line = Polygon(movement, closed=False, fill=False, edgecolor=color, label=label, linewidth=self._linewidth(visualizer)) ax.add_patch(line) dxy = movement[-1] - movement[-2] dxy = dxy / np.linalg.norm(dxy) * arrow_size origin = movement[-1] - dxy arrow = FancyArrow(*origin, *dxy, edgecolor=color, facecolor=color, width=2 * self._linewidth(visualizer), head_length=arrow_size, head_width=arrow_size) ax.add_patch(arrow) ax.legend(loc=0) return colors
def add_state_space_arrows(ax: matplotlib.axes.Axes): """Add arrows representing the axes to the plot. These arrows are used to indicate the axes variables without plotting a full axis, to give a less busy visualisation. """ # Add arrows to represent axis labels xarrow = FancyArrow(-1.31, -1.3, 0.3, 0, width=0.02, edgecolor='k', facecolor='k') ax.text(-0.8, -1.3, r'$p$', fontsize='xx-large', verticalalignment='center') ax.add_patch(xarrow) yarrow = FancyArrow(-1.3, -1.31, 0, 0.3, width=0.02, edgecolor='k', facecolor='k') ax.text(-1.3, -0.8, r'$\dot{p}$', fontsize='xx-large', horizontalalignment='center') ax.add_patch(yarrow)