def scatter_plot(self, equators=True, tagging=True, depth_cap=None): if depth_cap is None: depth_cap = self.height fig = plt.figure(figsize=(12, 10)) ax = fig.add_subplot(111, projection="3d") plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0) xs = [self.nodes[self.root].coord.x] ys = [self.nodes[self.root].coord.y] zs = [self.nodes[self.root].coord.z] plot_color_board = ["blue", "red", "yellow", "green", "black"] font0 = FontProperties() font0.set_size(8) current_generation = deque([self.root]) next_generation = True while next_generation: next_generation = deque() while current_generation: n = current_generation.popleft() if self.nodes[n].depth <= depth_cap: xs.append(self.nodes[n].coord.x) ys.append(self.nodes[n].coord.y) zs.append(self.nodes[n].coord.z) if tagging: ax.text(self.nodes[n].coord.x + 0.01, self.nodes[n].coord.y + 0.01, self.nodes[n].coord.z + 0.01, ("n{0}".format(n)), fontproperties=font0) for child in self.nodes[n].children: next_generation.append(child) if self.nodes[n].depth <= depth_cap: xe = [self.nodes[n].coord.x, self.nodes[child].coord.x] ye = [self.nodes[n].coord.y, self.nodes[child].coord.y] ze = [self.nodes[n].coord.z, self.nodes[child].coord.z] ax.plot(xe, ye, ze, plot_color_board[self.nodes[n].depth % 5]) current_generation = next_generation ax.scatter(xs, ys, zs, c="r", marker="o") global_radius = self.nodes[self.root].radius * 1.12 if equators: for axis in ["x", "y", "z"]: circle = Circle((0, 0), global_radius * 1.1) circle.set_clip_box(ax.bbox) circle.set_edgecolor("gray") circle.set_alpha(0.3) circle.set_facecolor("none") # "none" not None ax.add_patch(circle) art3d.pathpatch_2d_to_3d(circle, z=0, zdir=axis) ax.set_xlim([-1.2 * global_radius, 1.2 * global_radius]) ax.set_ylim([-1.2 * global_radius, 1.2 * global_radius]) ax.set_zlim([-1.2 * global_radius, 1.2 * global_radius]) ax.set_xlabel("X Label") ax.set_ylabel("Y Label") ax.set_zlabel("Z Label") plt.show()
def user_hotspot(num_users, radius): x = random.randint(int(2 * CELL_RADIUS), int(NETWORK_SIZE_X - 2 * CELL_RADIUS)) y = random.randint(int(2 * CELL_RADIUS), int(NETWORK_SIZE_Y - 2 * CELL_RADIUS)) bs_num = random.randint(0, len(basestations) - 1) mon_bs = [] for bs in monitored_basestations: mon_bs.append(bs.basestation_id) bs_num = random.choice(mon_bs) bs = basestations[bs_num] x, y = bs.coords coord = (x, y) hotspot = Circle(coord, radius) hotspot.set_facecolor('Red') hotspot.set_alpha(0.2) ax.add_patch(hotspot) current_users = 0 while current_users < num_users: x1 = random.randint(int(x - radius), int(x + radius)) y1 = random.randint(int(y - radius), int(y + radius)) point = (x1, y1) if hotspot.contains_point(ax.transData.transform(point)): user = User(x1, y1) user.user_id = len(users) user.bs = bs user.bs_coords = (bs.x_coord, bs.y_coord) user.first_tier_cells = bs.first_tier_cells if bs.monitored: monitored_users.append(user) user.plot_user() users.append(user) bs.users.append(user) current_users += 1
def annotate_all_halos(self, im, camera, color="lightsteelblue", facecolor="none", alpha=1, **kwargs): ''' Annotate halos on the projection im = proj.save_plot() ''' import matplotlib import matplotlib.pylab as plt from matplotlib.ticker import IndexLocator, FormatStrFormatter from matplotlib.colors import Colormap, LinearSegmentedColormap from matplotlib.patches import Circle import matplotlib.cm as cm ax = im.axes[0] los_axis = camera.los_axis pos = [] rvir = np.zeros(len(self)) m = None if hasattr(color, "__iter__"): norm = matplotlib.colors.Normalize(vmin=color.min(), vmax=color.max()) cmap = cm.get_cmap(kwargs.get("cmap", "jet")) m = cm.ScalarMappable(norm=norm, cmap=cmap) for i in range(len(self)): h = self[i] pos = h['pos'].in_units(self.boxsize) rvir = h['rvir'].in_units(self.boxsize) x, y = (None, None) if los_axis[0] == 1: x, y = (pos[1], pos[2]) if los_axis[1] == 1: x, y = (pos[0], pos[2]) if los_axis[2] == 1: x, y = (pos[0], pos[1]) else: raise Exception("los_axis must be along x,y or z") e = Circle(xy=(x, y), radius=rvir) ax.add_artist(e) e.set_clip_box(ax.bbox) if hasattr(color, "__iter__"): ci = color[i] c = m.to_rgba(ci) e.set_edgecolor(c) else: e.set_edgecolor(color) e.set_facecolor(facecolor) # "none" not None e.set_alpha(alpha)
def anno(ax, xy, rvir, color="lightsteelblue", facecolor="none", alpha=1): e = Circle(xy=xy, radius=rvir) ax.add_artist(e) e.set_clip_box(ax.bbox) e.set_edgecolor(color) e.set_facecolor(facecolor) # "none" not None e.set_alpha(alpha)
def circle( xy, radius, color="red", facecolor="none", alpha=1, ax=None ): """ add a circle to ax= or current axes """ # from .../pylab_examples/ellipse_demo.py e = Circle(xy=xy, radius=radius) if ax is None: ax = plt.gca() # ax = subplot( 1,1,1 ) ax.add_artist(e) e.set_clip_box(ax.bbox) e.set_edgecolor(color) e.set_facecolor(facecolor) # "none" not None e.set_alpha(alpha)
def circle( xy, radius, color="lightsteelblue", facecolor="none", alpha=1, ax=None ): """ add a circle to ax= or current axes """ # from .../pylab_examples/ellipse_demo.py e = Circle( xy=xy, radius=radius ) if ax is None: ax = plt.gca() # ax = subplot( 1,1,1 ) ax.add_artist(e) e.set_clip_box(ax.bbox) e.set_edgecolor( color ) e.set_facecolor( facecolor ) # "none" not None e.set_alpha( alpha )
def clusters_demo(np_seed=0, tf_seed=0, alpha=1.0, T=100, max_n_iter=20): data = gen_demo_data(batch_size=1, np_seed=np_seed) nonzero_datapoints_batches = np.where(~np.all(data == 0, axis=2)) for n_iter in [0, 1, 2, 5, 10, max_n_iter]: inferred_latents = variational_inference(data, alpha=alpha, T=T, n_iter=n_iter, tf_seed=tf_seed, get_elbo=False) #Plot means and datapoints as points batch_number = 0 nonzero_datapoints = nonzero_datapoints_batches[1][np.where( nonzero_datapoints_batches[0] == batch_number)] plt.scatter(data[batch_number, nonzero_datapoints, 0], data[batch_number, nonzero_datapoints, 1], marker='x') plt.scatter(inferred_latents.nu[batch_number, :, 0] + 0.01 * np.random.randn(T), inferred_latents.nu[batch_number, :, 1], marker='o', s=30, color='r') #Plot expected standard deviation as radius of circle patches = [] radii = np.sqrt(1. / np.divide(inferred_latents.a, inferred_latents.b)) #Plot marginal cluster probabilities as the transparency of circle l1 = inferred_latents.lambda_1[batch_number, :] l2 = inferred_latents.lambda_2[batch_number, :] beta_means = np.divide(l1, l1 + l2) log_beta_means = np.log(beta_means + 1e-30) cs = np.concatenate( ([0], np.cumsum(np.log(1 - beta_means + 1e-30)[:-1]))) #SBP beta_expectation = np.exp(log_beta_means + cs) beta_expectation /= (1. * np.sum(beta_expectation)) for k in range(T): circle = Circle((inferred_latents.nu[batch_number, k, 0], inferred_latents.nu[batch_number, k, 1]), radii[batch_number, k]) plt.gca().add_artist(circle) circle.set_alpha(beta_expectation[k]) plt.gca().set_xlim([-10, 10]) plt.gca().set_ylim([-10, 10]) plt.gca().set_aspect('equal', adjustable='box') plt.title('Variational distributions at iteration ' + str(n_iter)) plt.show()
def annotate_rvir(ax, rvir, color="lightsteelblue", facecolor="none", alpha=1): ''' Annotates the virial radius on the axis. Assumes zero centred, rvir and extent must have the same units ''' from matplotlib.patches import Circle xy = (0, 0) e = Circle(xy=xy, radius=rvir) ax.add_artist(e) e.set_clip_box(ax.bbox) e.set_edgecolor(color) e.set_facecolor(facecolor) # "none" not None e.set_alpha(alpha)
def plot_circle(cov, pos, color=None, ax=None, **kwargs): if ax is None: figure = plt.figure(figsize=(10, 10)) ax = plt.gca() ax.set_ylim(-1.5, 1.5) ax.set_xlim(-1.5, 1.5) assert cov[0, 0] == cov[1, 1] r = cov[0, 0] c = Circle(pos, r) if color is not None: c.set_color(color) c.set_alpha(0.5) ax.add_artist(c) return c
def plot_network(network, title, xlims, ylims): plt.figure() ax = plt.gca() for ia in network.interest_areas: color = 'blue' if not ia.is_hub else 'green' c = CircleUI((ia.center[0], ia.center[1]), ia.radius, facecolor=color, edgecolor='black') c.set_alpha(0.5) c.set_label(ia.name) ax.add_patch(c) ax.annotate(ia.name, xy=(ia.center[0], ia.center[1]), fontsize=8, ha="center") sensors_xs = [] sensors_ys = [] relays_xs = [] relays_ys = [] for sensor in network.graph.vertices: if sensor.get(key='is_relay'): relays_xs.append(sensor.get('location')[0]) relays_ys.append(sensor.get('location')[1]) else: sensors_xs.append(sensor.get('location')[0]) sensors_ys.append(sensor.get('location')[1]) ax.scatter(sensors_xs, sensors_ys, s=5, c='red', alpha=1) ax.scatter(relays_xs, relays_ys, s=5, c='green', alpha=1) for edge in network.graph.edges: sensor1 = edge.v1 sensor2 = edge.v2 ui_line = Line2D( [sensor1.get('location')[0], sensor2.get('location')[0]], [sensor1.get('location')[1], sensor2.get('location')[1]], linewidth=1, color='black') ax.add_line(ui_line) ax.set_title('Adhoc Network') plt.xlim(xlims[0], xlims[1]) plt.ylim(ylims[0], ylims[1]) plt.title(title) plt.show()
def plot_interest_areas(interest_areas, xlims, ylims): plt.figure() ax = plt.gca() for ia in interest_areas: color = 'blue' if not ia.is_hub else 'green' c = CircleUI((ia.center[0], ia.center[1]), ia.radius, facecolor=color, edgecolor='black') c.set_alpha(0.5) c.set_label(ia.name) ax.add_patch(c) ax.annotate(ia.name, xy=(ia.center[0], ia.center[1]), fontsize=8, ha="center") plt.xlim(xlims[0], xlims[1]) plt.ylim(ylims[0], ylims[1]) plt.title('Interest Areas') plt.show()
def annotate_rvir(self, proj, color="lightsteelblue", facecolor="none", alpha=1, ax=None, **kwargs): ''' Draw the virial radius on a projection plot ''' import matplotlib.pylab as plt from matplotlib.ticker import IndexLocator, FormatStrFormatter from matplotlib.colors import Colormap, LinearSegmentedColormap from matplotlib.patches import Circle if ax is None: ax = plt.gca() camera = proj.camera region_size = camera.region_size[0] # code length map_max_size = camera.map_max_size # projection size in pixels unit_l = self.base.array(self.base.info["unit_length"]) rvir = self.rvir.in_units(unit_l) rvir_pixels = (rvir / region_size) * map_max_size xy = (map_max_size / 2, map_max_size / 2) e = Circle(xy=xy, radius=rvir_pixels) ax.add_artist(e) e.set_clip_box(ax.bbox) e.set_edgecolor(color) e.set_facecolor(facecolor) # "none" not None e.set_alpha(alpha) return e
def plot(self, fname, ax=None, wayPt=None, numObst=None): ''' Plots all the way points over all iterations ''' from pylab import rand from matplotlib.patches import Ellipse, Circle if ax == None: fig = plt.figure() ax = fig.add_subplot(111, aspect='equal') colormap = plt.cm.gist_ncar ## Different color points clrMap = [ colormap(i) for i in np.linspace(0, 0.9, len(self.__wayPoints)) ] if numObst == None: numObst = len(self.__V) ## Plot obstacles for corners in self.__V[:numObst]: x = corners[:, 0] y = corners[:, 1] plt.fill(x, y, color='black') ## Plot Waypoints if self.feasible or (wayPt != None): if wayPt == None: wayPt = self.getWayPoints() covar = self.__coVarMat for i, (pt1, pt2) in enumerate(zip(wayPt[:-1], wayPt[1:])): if (i == len(wayPt) - 2) and self.receding_horizon: # Receding horizon to not plot that last time step break #ax.plot([pt1[0], pt2[0]], [pt1[1], pt2[1]], c=clrMap[-1]) ax.plot([pt1[0], pt2[0]], [pt1[1], pt2[1]], c='r') ax.scatter(pt1[0], pt1[1], c='g') ax.scatter(pt2[0], pt2[1], c='g') #if (i > 0) and (i<(len(wayPt) -1)): # ells = Ellipse(np.array(wayPt[i]), width=3*(covar[i-1][0][0]), \ # height=3*(covar[i-1][1][1]), angle=0) # ax.add_artist(ells) # ells.set_alpha(0.4) # ells.set_facecolor('g') if self.receding_horizon: pt1 = wayPt[-2] pt2 = wayPt[-1] ax.plot([pt1[0], pt2[0]], [pt1[1], pt2[1]], linestyle='--', c='r') ax.scatter(pt2[0], pt2[1], c='g') # Plot the circle around the last way point horizon = Circle(wayPt[-2], radius=self.horizon_radius) ax.add_artist(horizon) horizon.set_alpha(0.2) horizon.set_facecolor('g') else: ax.scatter(self.start_location[0], self.start_location[1], c='g') ax.scatter(self.end_location[0], self.end_location[1], c='g') if fname != None: plt.savefig(self.outFolder + '/' + str(fname) + '.png') plt.close('all') return
def circleFromRMS(xy, rad): cir = Circle(xy, rad) cir.set_clip_box(ax.bbox) cir.set_alpha(0.2) cir.set_facecolor(tableau20[0]) return cir
fx = lambdify(z, solution[2][x], "numpy") fy = lambdify(z, solution[2][y], "numpy") values = numpy.arange(start=-100.0, stop=200.0, step=10.0) es = [] for v in values: es.append( Ellipse( xy=numpy.zeros(2), width=2 * math.fabs(fx(v)), height=2 * math.fabs(fy(v)), fill=False, ) ) print("Circle") r = math.sqrt((0.5 * l) ** 2 + (0.5 * h) ** 2) print(f"r = {r}") circle = Circle(xy=numpy.zeros(2), radius=r) circle.set_alpha(0.5) figure.add_artist(ellipse) figure.add_artist(circle) figure.add_artist(rectangle) for e in es: figure.add_artist(e) plt.xlim(-l, l) plt.ylim(-l, l) plt.show()
matplotlib.rcParams['lines.linewidth'] = 2 pyplot.axis([0, gridWidth, 0, gridHeight]) pyplot.grid(True) # Setting the axis labels. pyplot.xlabel('X Space') pyplot.ylabel('Y Space') #Give the plot a title pyplot.title('Radius Search Plot Using Shapely (%d Points)' % (numberOfPoints)) # Draw the collision circle/boundary cir = Circle((circleX, circleY), radius=circleRadius, fc='b') cir.set_alpha(0.4) pyplot.gca().add_patch(cir) for idx, point in enumerate(pointList): style = 'go' iAlpha = 0.4 if(idx in matchingPoints): style = 'ro' iAlpha = 1 pyplot.plot(point[0], point[1], style, linewidth=1, markersize=3, alpha=iAlpha) pyplot.savefig(os.getcwd()+'/'+str(filename))
# scipy.misc.imsave('snoop_img/{}.png'.format(n), s) # activation_img_tuple.append(M) # activation_img = np.concatenate(activation_img_tuple, axis=1) # ax3.imshow(activation_img) # ''' Visualize the features detected! ''' if settings['encoder_transform'] in ['softargmax', 'dense_spatial']: for i, (x,y,r) in enumerate(zip(positions[0,:],positions[1,:],positions[2,:]) ): feature_range = np.ptp(snoops[1][0,:,:,i]) print("Feature{}: x={}, y={}, p={}, m={}".format(i,x,y,r,feature_range)) X = 0.5*(1+y)*scale Y = 0.5*(1+x)*scale radius = [1.5, 7] transparency = 1 #min(1,max(0,r)) if i not in color_dict: color_dict[i] = np.random.rand(3) #color_dict[i] = np.array([1,0,0]) #if i in [11, 5]: # #color_dict[i] = np.random.rand(3) # color_dict[i] = np.array([1,0,0]) if i==5 else np.array([1,1,0]) # c = Circle((size[0]*X,size[1]*Y), radius=radius[1]*scale, fill=False, linewidth=3.0 ) #else: # continue c = Circle((size[0]*X,size[1]*Y), radius=radius[0]*scale, fill=True ) c.set_alpha(transparency) c.set_antialiased(True) c.set_ec(color_dict[i]) c.set_fc(color_dict[i]) ax2.add_patch(c) print("Loss (error,smooth,presence): {} + {} + {}".format(error_loss, smooth_loss, presence_loss)) plt.show()
def scatter_plot(self, equators=True, tagging=True, depth_cap=None, node_coloring=None): """ Plot the tree with nodes and edges, optionally equators and tagging nodes with node numbers. The tree is traversed in a breath-first-search. Note: - To distinct each generations, a color plate of ["blue", "red", "yellow", "green", "black"] is used repeatedly. - The X, Y, Z axises have been labelled. - When the number of nodes is large and the tree is bushy, it's advised disabling tagging for better user experience. :param bool equators: whether to draw the 3D equators, default True :param bool tagging: whether to tag nodes with node numbers, default True :param int depth_cap: a filter for rendering the first N generations, default tree height :param dict node_coloring: an optional map from node_id : color, to color individual nodes """ if depth_cap is None: depth_cap = self.height fig = plt.figure(figsize=(12, 10)) ax = fig.add_subplot(111, projection="3d") plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0) xs = [self.nodes[self.root.node_id].coord.x] ys = [self.nodes[self.root.node_id].coord.y] zs = [self.nodes[self.root.node_id].coord.z] plot_color_board = ["blue", "red", "yellow", "green", "black"] font0 = FontProperties() font0.set_size(8) current_generation = deque([self.root.node_id]) next_generation = True while next_generation: next_generation = deque() while current_generation: n = current_generation.popleft() if self.nodes[n].depth <= depth_cap: xs.append(self.nodes[n].coord.x) ys.append(self.nodes[n].coord.y) zs.append(self.nodes[n].coord.z) if tagging: ax.text(self.nodes[n].coord.x + 0.01, self.nodes[n].coord.y + 0.01, self.nodes[n].coord.z + 0.01, ("n{0}".format(n)), fontproperties=font0) for child in self.nodes[n].children: next_generation.append(child.node_id) if self.nodes[n].depth <= depth_cap: xe = [self.nodes[n].coord.x, self.nodes[child.node_id].coord.x] ye = [self.nodes[n].coord.y, self.nodes[child.node_id].coord.y] ze = [self.nodes[n].coord.z, self.nodes[child.node_id].coord.z] if node_coloring: ax.plot(xe, ye, ze, node_coloring.get(n, 'black')) else: ax.plot(xe, ye, ze, plot_color_board[self.nodes[n].depth % 5]) current_generation = next_generation ax.scatter(xs, ys, zs, c="r", marker="o") global_radius = self.nodes[self.root.node_id].radius * 1.12 if equators: for axis in ["x", "y", "z"]: circle = Circle((0, 0), global_radius * 1.1) circle.set_clip_box(ax.bbox) circle.set_edgecolor("gray") circle.set_alpha(0.3) circle.set_facecolor("none") # "none" not None ax.add_patch(circle) art3d.pathpatch_2d_to_3d(circle, z=0, zdir=axis) ax.set_xlim([-1.2 * global_radius, 1.2 * global_radius]) ax.set_ylim([-1.2 * global_radius, 1.2 * global_radius]) ax.set_zlim([-1.2 * global_radius, 1.2 * global_radius]) ax.set_xlabel("X Label") ax.set_ylabel("Y Label") ax.set_zlabel("Z Label") plt.show()
# Time : about three days time = np.arange(0, 265600, 1) orbit = odeint(threebody, Y0, time) x, y, z, a, b, c, dx, dy, dz, da, db, dc = orbit.T # Figure fig = plt.figure(figsize=(13, 8)) ax = fig.gca(projection='3d') ax.scatter(a[0], b[0], c[0], s=2000, c='b') # Moon's orbit plane plane = Circle((a[0], b[0]), ((a[0] - x[0])**2 + (b[0] - y[0])**2 + (c[0] - z[0])**2)**0.5) Circle.set_color(plane, '0.75') Circle.set_alpha(plane, 0.1) ax.add_patch(plane) art3d.pathpatch_2d_to_3d(plane, z=0, zdir="z") # Some stars (real stars should *NOT* move so quickly!) ax.set_axis_bgcolor('#060A49') for k in range(50): X = randint(-5 * 10**8, 5 * 10**8) Y = randint(-1.5 * 10**8 * 2, 3 * 10**8 * 2) Z = randint(-500000 * 2, 4000000 * 2) ax.scatter(X, Y, Z, s=0.1, marker='x', c='white') # Spaceship's orbit for k in range(10, len(x), 2270): i = (k - 10) // 2270
class DraufsichtRoboter(QObject): 'Signal definieren' xy_neu = Signal(float, float, float, float, float, float) 'Klassenattribut lock definieren' lock = None 'Methode __init__' def __init__(self, parent, xP1, yP1, xP2, yP2, xP4, yP4, xP5, yP5): 'Vererbung aller Attribute und Methoden von QObject' super(DraufsichtRoboter, self).__init__(parent) 'Parentobjekt - QPlotWidget' self.parent = parent 'Kartesische Koordinaten' self.xP1 = xP1 self.yP1 = yP1 'Umrechnung in Polarkoordinaten' self.modellrechnung(xP2, yP2, xP4, yP4, xP5, yP5) 'Grenzwinkel festlegen' self.theta1_min = 0 self.theta1_max = pi 'Farben der Punkte und Linien festlegen' self.farbe_allgemein = 'black' self.farbe_punkt = '#5c061c' self.alpha_allgemein = 0.5 self.alpha_geist = 0.25 'Punktradius, Linienstärke und Linienende festlegen' self.radius_punkt = 55 self.staerke_linie = 20 self.ende_linie = 'round' 'Circle-Objekte instanziieren' 'Punkt1 instanziieren' #Fixpunkt im Ursprung des Koordinatensystems self.point1 = Circle((self.xP1, self.yP1)) self.point1.set_radius(self.radius_punkt) self.point1.set_facecolor(self.farbe_allgemein) self.point1.set_alpha(self.alpha_allgemein) self.parent.axes.add_patch(self.point1) 'Punkt2 instanziieren' self.point2 = Circle((self.xP2, self.yP2)) self.point2.set_radius(self.radius_punkt) self.point2.set_facecolor(self.farbe_allgemein) self.point2.set_alpha(self.alpha_allgemein) self.parent.axes.add_patch(self.point2) 'Punkt4 instanziieren' self.point4 = Circle((self.xP4, self.yP4)) self.point4.set_radius(self.radius_punkt) self.point4.set_facecolor(self.farbe_allgemein) self.point4.set_alpha(self.alpha_allgemein) self.parent.axes.add_patch(self.point4) 'Punkt5 instanziieren' self.point5 = Circle((self.xP5, self.yP5)) self.point5.set_radius(self.radius_punkt) self.point5.set_facecolor(self.farbe_allgemein) self.point5.set_alpha(self.alpha_allgemein) self.parent.axes.add_patch(self.point5) self.point = self.point4 'Line2D-Objekte instanziieren' 'Endpunktkoordinaten von Linie1' #Linie1 - verbindet Punkt1 mit Punkt2 self.xL1 = (self.xP1, self.xP2) self.yL1 = (self.yP1, self.yP2) 'Linie1 instanziieren' self.line1 = Line2D(self.xL1, self.yL1) self.line1.set_linewidth(self.staerke_linie) self.line1.set_color(self.farbe_allgemein) self.line1.set_alpha(self.alpha_allgemein) self.line1.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.line1) 'Endpunktkoordinaten von Linie2' #Linie2 - verbindet Punkt2 mit Punkt4 self.xL2 = (self.xP2, self.xP4) self.yL2 = (self.yP2, self.yP4) 'Linie2 instanziieren' self.line2 = Line2D(self.xL2, self.yL2) self.line2.set_linewidth(self.staerke_linie) self.line2.set_color(self.farbe_allgemein) self.line2.set_alpha(self.alpha_allgemein) self.line2.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.line2) 'Endpunktkoordinaten von Linie3' #Linie3 - verbindet Punkt4 mit Punkt5 self.xL3 = (self.xP4, self.xP5) self.yL3 = (self.yP4, self.yP5) 'Linie3 instanziieren' self.line3 = Line2D(self.xL3, self.yL3) self.line3.set_linewidth(self.staerke_linie) self.line3.set_color(self.farbe_allgemein) self.line3.set_alpha(self.alpha_allgemein) self.line3.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.line3) 'Geisterpunktobjekte instanziieren' 'Geisterpunkt2 instanziieren' self.pointG2 = Circle((self.xP2, self.yP2)) self.pointG2.set_radius(self.radius_punkt) self.pointG2.set_facecolor(self.farbe_allgemein) self.pointG2.set_alpha(self.alpha_geist) self.parent.axes.add_patch(self.pointG2) self.pointG2.set_visible(False) 'Geisterpunkt4 instanziieren' self.pointG4 = Circle((self.xP4, self.yP4)) self.pointG4.set_radius(self.radius_punkt) self.pointG4.set_facecolor(self.farbe_punkt) self.pointG4.set_alpha(self.alpha_geist) self.parent.axes.add_patch(self.pointG4) self.pointG4.set_visible(False) 'Geisterpunkt5 instanziieren' self.pointG5 = Circle((self.xP5, self.yP5)) self.pointG5.set_radius(self.radius_punkt) self.pointG5.set_facecolor(self.farbe_allgemein) self.pointG5.set_alpha(self.alpha_geist) self.parent.axes.add_patch(self.pointG5) self.pointG5.set_visible(False) 'Geisterlinienobjekte instanziieren' 'Geisterlinie1 instanziieren' self.lineG1 = Line2D(self.xL1, self.yL1) self.lineG1.set_linewidth(self.staerke_linie) self.lineG1.set_color(self.farbe_allgemein) self.lineG1.set_alpha(self.alpha_geist) self.lineG1.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.lineG1) self.lineG1.set_visible(False) 'Geisterlinie2 instanziieren' self.lineG2 = Line2D(self.xL2, self.yL2) self.lineG2.set_linewidth(self.staerke_linie) self.lineG2.set_color(self.farbe_allgemein) self.lineG2.set_alpha(self.alpha_geist) self.lineG2.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.lineG2) self.lineG2.set_visible(False) 'Geisterlinie3 instanziieren' self.lineG3 = Line2D(self.xL3, self.yL3) self.lineG3.set_linewidth(self.staerke_linie) self.lineG3.set_color(self.farbe_allgemein) self.lineG3.set_alpha(self.alpha_geist) self.lineG3.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.lineG3) self.lineG3.set_visible(False) 'Attribut self.press' self.press = None 'Attribut self.background' self.background = None 'Aufruf der Methode connect' self.connect() '''Methode connect - Die Methode dient dem Verbinden der Events mit den entsprechenden Methoden. Beim Drücken der linken Maustaste, dem button_ press_event, wird die Methode on_press ausgeführt. Weiter führt das Loslassen der linken Maustaste, dem button_release_event, zum Ausführen der Methode on_release. Zuletzt wird bei der Bewegung der Maus, dem motion_notify_event, die Methode on_motion aufgerufen. Vorraussetzung für ein Event ist das Drücken oder Loslassen der linken Maustaste auf oder das Bewegen der Maus über die Zeichenfläche.''' def connect(self): 'Verbindet das button_press_event mit der Methode on_press' self.cidpress = self.point.figure.canvas.mpl_connect( 'button_press_event', self.on_press) 'Verbindet das button_release_event mit der Methode on_release' self.cidrelease = self.point.figure.canvas.mpl_connect( 'button_release_event', self.on_release) 'Verbindet das motion_notify_event mit der Methode on_motion' self.cidmotion = self.point.figure.canvas.mpl_connect( 'motion_notify_event', self.on_motion) '''Methode on_press - Die Methode on_press wird beim Drücken der linken Maustaste auf der Zeichenfläche ausgeführt.''' def on_press(self, event): '''Die Methode wird weiter ausgeführt wenn der Mauszeiger zum Zeitpunkt des Drückens der linken Maustaste innerhalb des Koordinatensystems liegt.''' if event.inaxes != self.point.axes: return '''Die Methode wird weiter ausgeführt wenn vor dem Drücken der linken Maustaste kein Circle-Objekt ausgewählt ist.''' if DraufsichtRoboter.lock is not None: return contains, attrd = self.point.contains(event) '''Die Methode wird weiter ausgeführt wenn der Mauszeiger zum Zeitpunkt des Drückens der linken Maustaste auf dem bewegbaren Circle-Objekt liegt.''' if not contains: return '''Den Mittelpunkt des Circle-Objektes und die x- und y-Koordinaten des Mauszeigers zum Zeitpunkt des Drückens der linken Maustaste speichern.''' self.press = self.point.center, event.xdata, event.ydata 'Das Klassenattribut mit dem Wert self belegen.' DraufsichtRoboter.lock = self 'Sichtbarkeit des Geistes ändern' self.pointG2.set_visible(True) self.pointG4.set_visible(True) self.pointG5.set_visible(True) self.lineG1.set_visible(True) self.lineG2.set_visible(True) self.lineG3.set_visible(True) 'Methoden der Animation-Blit-Technik ausführen' canvas = self.point.figure.canvas axes = self.point.axes self.point2.set_animated(True) self.point4.set_animated(True) self.point5.set_animated(True) self.line1.set_animated(True) self.line2.set_animated(True) self.line3.set_animated(True) canvas.draw() self.background = canvas.copy_from_bbox(self.point.axes.bbox) axes.draw_artist(self.point2) axes.draw_artist(self.point4) axes.draw_artist(self.point5) axes.draw_artist(self.line1) axes.draw_artist(self.line2) axes.draw_artist(self.line3) canvas.blit(axes.bbox) '''Methode on_motion - Die Methode on_motion wird beim Bewegen des Mauszeigers über die Zeichenfläche ausgeführt.''' def on_motion(self, event): '''Die Methode wird weiter ausgeführt wenn das Klassenattribut mit dem Wert self belegt ist. Das Circle-Objekt darf ohne angeklickt zu sein nicht bewegt werden.''' if DraufsichtRoboter.lock is not self: return '''Die Methode wird weiter ausgeführt wenn der Mauszeiger innerhalb des Koordinatensystems bewegt wird.''' if event.inaxes != self.point.axes: return '''Den Mittelpunkt des Circle-Objektes und die x- und y-Koordinaten des Mauszeigers zum Zeitpunkt des Drückens der linken Maustaste zuweisen.''' self.point.center, xpress, ypress = self.press 'Winkel aller Circle-Objekte neu berechnen' 'Winkel berechnen - Kreismittelpunkt' phi = winkel_berechnen(self.point4.center[0], self.point4.center[1]) 'Winkel berechnen - Mauszeiger beim Anklicken des Punktes' phi_p = winkel_berechnen(xpress, ypress) 'Winkel berechnen - Mauszeiger bei der Bewegung' phi_e = winkel_berechnen(event.xdata, event.ydata) 'Winkeländerung berechnen' dphi = phi_e - phi_p 'neuen Positionswinkel berechnen' phi_neu = phi + dphi 'Winkel auf [0, 2*pi] normieren um Rundungsfehler auszugleichen' phi_neu = winkel_normieren(phi_neu) 'Winkelgrenzen zuweisen' phi_min = self.theta1_min phi_max = self.theta1_max 'Winkelbegrenzung [phi_min, phi_max]' if phi_neu <= phi_min or phi_neu > 3*pi/2 and phi_neu < 2*pi: phi_neu = phi_min elif phi_neu >= phi_max: phi_neu = phi_max 'Winkel von Punkt2 aktualisieren' #Rundungsfehler berücksichtigen if round(self.phi2, 3) == round(self.phi4, 3): self.phi2 = phi_neu elif round(self.phi2, 3) != round(self.phi4, 3): self.phi2 = phi_neu + pi 'Winkel von Punkt4 aktualisieren' self.phi4 = phi_neu 'Winkel von Punkt5 aktualisieren' self.phi5 = self.phi4 'Theta1 (Denavit-Hartenberg-Parameter) aktualisieren' self.theta1 = self.phi4 'Mittelpunktkoordinaten der Circle-Objekte aktualisieren' 'Koordinaten von Punkt2' self.xP2 = self.r2*cos(self.phi2) self.yP2 = self.r2*sin(self.phi2) 'Koordinaten akualisieren' self.point2.center = ((self.xP2, self.yP2)) 'Koordinaten von Punkt4' self.xP4 = self.r4*cos(self.phi4) self.yP4 = self.r4*sin(self.phi4) 'Koordinaten akualisieren' self.point4.center = ((self.xP4, self.yP4)) 'Koordinaten von Punkt5' self.xP5 = self.r5*cos(self.phi5) self.yP5 = self.r5*sin(self.phi5) 'Koordinaten akualisieren' self.point5.center = ((self.xP5, self.yP5)) 'Endpunktkoordinaten der Line2D-Objekte aktualisieren' 'Koordinaten von Linie1' self.xL1 = (self.point1.center[0], self.point2.center[0]) self.yL1 = (self.point1.center[1], self.point2.center[1]) 'Koordinaten akualisieren' self.line1.set_data(self.xL1, self.yL1) 'Koordinaten von Linie2' self.xL2 = (self.point2.center[0], self.point4.center[0]) self.yL2 = (self.point2.center[1], self.point4.center[1]) 'Koordinaten akualisieren' self.line2.set_data(self.xL2, self.yL2) 'Koordinaten von Linie3' self.xL3 = (self.point4.center[0], self.point5.center[0]) self.yL3 = (self.point4.center[1], self.point5.center[1]) 'Koordinaten akualisieren' self.line3.set_data(self.xL3, self.yL3) 'Methoden der Animation-Blit-Technik ausführen' canvas = self.point.figure.canvas axes = self.point.axes canvas.restore_region(self.background) axes.draw_artist(self.point2) axes.draw_artist(self.point4) axes.draw_artist(self.point5) axes.draw_artist(self.line1) axes.draw_artist(self.line2) axes.draw_artist(self.line3) canvas.blit(axes.bbox) 'Signal mit den neuen Koordinaten senden' self.xy_neu.emit(self.xP2, self.yP2, self.xP4, self.yP4, \ self.xP5, self.yP5) '''Methode on_release - Die Methode on_release wird beim Loslassen der linken Maustaste auf der Zeichenfläche ausgeführt.''' def on_release(self, event): '''Die Methode wird weiter ausgeführt wenn das Klassenattribut mit dem Wert self belegt ist.''' if DraufsichtRoboter.lock is not self: return 'Werte der Attribute zurücksetzen' self.press = None DraufsichtRoboter.lock = None 'Attribute auf False setzen' self.point2.set_animated(False) self.point4.set_animated(False) self.point5.set_animated(False) self.line1.set_animated(False) self.line2.set_animated(False) self.line3.set_animated(False) 'Hintergrund zurücksetzen' self.background = None 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw() '''Methode ansicht_aktualisieren - Die Methode ermöglicht das Aktualisieren der Ansicht.''' def ansicht_aktualisieren(self, xP2, yP2, xP4, yP4, xP5, yP5): 'Umrechnung in Polarkoordinaten' self.modellrechnung(xP2, yP2, xP4, yP4, xP5, yP5) 'Mittelpunktkoordinaten der Circle-Objekte aktualisieren' 'Koordinaten von Punkt2 aktualisieren' self.point2.center = (self.xP2, self.yP2) 'Koordinaten von Punkt4 aktualisieren' self.point4.center = (self.xP4, self.yP4) 'Koordinaten von Punkt5 aktualisieren' self.point5.center = (self.xP5, self.yP5) 'Endpunktkoordinaten der Line2D-Objekte aktualisieren' 'Koordinaten von Linie1' self.xL1 = (self.xP1, xP2) self.yL1 = (self.yP1, yP2) 'Koordinaten aktualisieren' self.line1.set_data(self.xL1, self.yL1) 'Koordinaten von Linie2' self.xL2 = (xP2, xP4) self.yL2 = (yP2, yP4) 'Koordinaten aktualisieren' self.line2.set_data(self.xL2, self.yL2) 'Koordinaten von Linie3' self.xL3 = (xP4, xP5) self.yL3 = (yP4, yP5) 'Koordinaten aktualisieren' self.line3.set_data(self.xL3, self.yL3) 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw() '''Methode geisterstunde - Die Methode dient dem Ein- oder Ausblenden des Geistes. Weiter werden die Koordinaten des Geistes aktualisiert.''' def geisterstunde(self, b): 'Mittelpunktkoordinaten der Circle-Objekte aktualisieren' 'Koordinaten von Geisterpunkt2' xGp2 = self.point2.center[0] yGp2 = self.point2.center[1] 'Koordinaten aktualisieren' self.pointG2.center = (xGp2, yGp2) 'Koordinaten von Geisterpunkt4' xGp4 = self.point4.center[0] yGp4 = self.point4.center[1] 'Koordinaten aktualisieren' self.pointG4.center = (xGp4, yGp4) 'Koordinaten von Geisterpunkt5' xGp5 = self.point5.center[0] yGp5 = self.point5.center[1] 'Koordinaten aktualisieren' self.pointG5.center = (xGp5, yGp5) 'Endpunktkoordinaten der Line2D-Objekte aktualisieren' 'Koordinaten von Geisterlinie1' xGl1 = (self.point1.center[0], self.point2.center[0]) yGl1 = (self.point1.center[1], self.point2.center[1]) 'Koordinaten akualisieren' self.lineG1.set_data(xGl1, yGl1) 'Koordinaten von Geisterlinie2' xGl2 = (self.point2.center[0], self.point4.center[0]) yGl2 = (self.point2.center[1], self.point4.center[1]) 'Koordinaten akualisieren' self.lineG2.set_data(xGl2, yGl2) 'Koordinaten von Geisterlinie3' xGl3 = (self.point4.center[0], self.point5.center[0]) yGl3 = (self.point4.center[1], self.point5.center[1]) 'Koordinaten akualisieren' self.lineG3.set_data(xGl3, yGl3) 'Sichtbarkeit des Geistes ändern' #Sichtbarkeit ändern - True oder False self.pointG2.set_visible(b) self.pointG4.set_visible(b) self.pointG5.set_visible(b) self.lineG1.set_visible(b) self.lineG2.set_visible(b) self.lineG3.set_visible(b) 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw() '''Methode modellrechnung - Die Methode rechnet die kartesischen Mittelpunktkoordinaten in Polarkoordinaten um.''' def modellrechnung(self, xP2, yP2, xP4, yP4, xP5, yP5): 'Kartesische Koordinaten' 'Punkt2, Punkt4 und Punkt5' self.xP2 = xP2 self.yP2 = yP2 self.xP4 = xP4 self.yP4 = yP4 self.xP5 = xP5 self.yP5 = yP5 'Polarkoordinaten' 'Radien von Punkt2, Punkt4 und Punkt5' self.r2 = ((self.xP2 - self.xP1)**2 + (self.yP2 - self.yP1)**2)**(1/2) self.r4 = ((self.xP4 - self.xP1)**2 + (self.yP4 - self.yP1)**2)**(1/2) self.r5 = ((self.xP5 - self.xP1)**2 + (self.yP5 - self.yP1)**2)**(1/2) 'Winkel im Intervall [0, 2*pi]' 'Winkel von Punkt2 berechnen' self.phi2 = winkel_berechnen(self.xP2, self.yP2) 'Winkel von Punkt4 berechnen' self.phi4 = winkel_berechnen(self.xP4, self.yP4) 'Winkel von Punkt5 berechnen' self.phi5 = self.phi4 'Theta1 (Denavit-Hartenberg-Parameter) berechnen' self.theta1 = self.phi4 '''Methode punkte_faerben - Die Methode färbt oder entfärbt das bewegbare Circle-Objekt.''' def punkte_faerben(self, b): 'Fallunterscheidung' if b == True: #Farbe farbe = self.farbe_punkt elif b == False: #Schwarz farbe = self.farbe_allgemein 'Farbe von Punkt4 festlegen' self.point4.set_facecolor(farbe) 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw()
import matplotlib.pyplot as pyplot matplotlib.rcParams['lines.linewidth'] = 2 pyplot.axis([0, gridWidth, 0, gridHeight]) pyplot.grid(True) # Setting the axis labels. pyplot.xlabel('X Space') pyplot.ylabel('Y Space') #Give the plot a title pyplot.title('Radius Search Plot Using Shapely (%d Points)' % (numberOfPoints)) # Draw the collision circle/boundary cir = Circle((circleX, circleY), radius=circleRadius, fc='b') cir.set_alpha(0.4) pyplot.gca().add_patch(cir) for idx, point in enumerate(pointList): style = 'go' iAlpha = 0.4 if (idx in matchingPoints): style = 'ro' iAlpha = 1 pyplot.plot(point[0], point[1], style, linewidth=1, markersize=3, alpha=iAlpha)
circle = Circle((0,0), 1., facecolor=col, edgecolor='k', alpha=1.0) ax.add_patch(circle) ax.set_frame_on(False) ax.set_xticks([]) ax.set_yticks([]) plt.draw() ax.set_xlim([-1.2,1.2]) ax.set_ylim([-1.2,1.2]) marble_png = print_figure(fig, 'png') marble_png64 = encodestring(marble_png).decode('ascii') _marble_cache[symb] = '<img src="data:image/png;base64,%s" height="40" width="40">' % marble_png64 circle.set_alpha(0.25) ax.scatter([0,0], [0,0], s=55000, marker=r'$\checkmark$', color='green') marble_png = print_figure(fig, 'png') marble_png64 = encodestring(marble_png).decode('ascii') _marble_cache[(symb,True)] = '<img src="data:image/png;base64,%s" height="40" width="40">' % marble_png64 plt.close() def numbered_marble(col, number): if (col, number) not in _marble_cache: fig = plt.figure(figsize=(4,4)) ax = fig.gca() ax.set_xlim([-1.2,1.2]) ax.set_ylim([-1.2,1.2]) circle = Circle((0,0), 1., facecolor=col, edgecolor='k', alpha=0.7)
circle = Circle((0, 0), 1.0, facecolor=col, edgecolor="k", alpha=1.0) ax.add_patch(circle) ax.set_frame_on(False) ax.set_xticks([]) ax.set_yticks([]) plt.draw() ax.set_xlim([-1.2, 1.2]) ax.set_ylim([-1.2, 1.2]) marble_png = print_figure(fig, "png") marble_png64 = encodestring(marble_png).decode("ascii") _marble_cache[symb] = '<img src="data:image/png;base64,%s" height="40" width="40">' % marble_png64 circle.set_alpha(0.25) ax.scatter([0, 0], [0, 0], s=55000, marker=r"$\checkmark$", color="green") marble_png = print_figure(fig, "png") marble_png64 = encodestring(marble_png).decode("ascii") _marble_cache[(symb, True)] = '<img src="data:image/png;base64,%s" height="40" width="40">' % marble_png64 plt.close() def numbered_marble(col, number): if (col, number) not in _marble_cache: fig = plt.figure(figsize=(4, 4)) ax = fig.gca() ax.set_xlim([-1.2, 1.2]) ax.set_ylim([-1.2, 1.2]) circle = Circle((0, 0), 1.0, facecolor=col, edgecolor="k", alpha=0.7)
class SeitenansichtRoboter(QObject): 'Signal definieren' xy_neu = Signal(float, float, float, float, float, float, float, float) 'Klassenattribut lock definieren' lock = None 'Methode __init__' def __init__(self, parent, xP1, yP1, xP2, yP2, xP3, yP3, \ xP4, yP4, xP5, yP5): 'Vererbung aller Attribute und Methoden von QObject' super(SeitenansichtRoboter, self).__init__(parent) 'Parentobjekt - QPlotWidget' self.parent = parent 'Kartesische Koordinaten' self.xP1 = xP1 self.yP1 = yP1 'Längen berechnen' self.a2 = ((xP2 - xP1)**2 + (yP2 - yP1)**2)**(1 / 2) self.a3 = ((xP4 - xP2)**2 + (yP4 - yP2)**2)**(1 / 2) 'Zeichenwinkel berechnen' self.modellrechnung(xP2, yP2, xP3, yP3, xP4, yP4, xP5, yP5) 'Kleinsten x-Wert und y-Wert festlegen' self.x_min = 0.001 self.y_min = 45 'Grenzwinkel festlegen' self.theta2_min = 0 self.theta2_max = pi self.theta3_min = -(pi - 8 * pi / 180) self.theta3_max = 0 self.theta4_min = -8 * pi / 180 self.theta4_max = pi - 8 * pi / 180 'Farben der Punkte und Linien festlegen' self.farbe_allgemein = 'black' self.farbe_punkt = '#5c061c' self.alpha_allgemein = 0.5 self.alpha_geist = 0.25 'Punktradius, Linienstärke und Linienende festlegen' self.radius_punkt = 55 self.staerke_linie = 20 self.ende_linie = 'round' 'Circle-Objekte instanziieren' 'Punkt1 instanziieren' #Fixpunkt im Ursprung des Koordinatensystems self.point1 = Circle((self.xP1, self.yP1)) self.point1.set_radius(self.radius_punkt) self.point1.set_facecolor(self.farbe_allgemein) self.point1.set_alpha(self.alpha_allgemein) self.parent.axes.add_patch(self.point1) 'Punkt2 instanziieren' self.point2 = Circle((self.xP2, self.yP2)) self.point2.set_radius(self.radius_punkt) self.point2.set_facecolor(self.farbe_allgemein) self.point2.set_alpha(self.alpha_allgemein) self.parent.axes.add_patch(self.point2) 'Punkt3 instanziieren' self.point3 = Circle((self.xP3, self.yP3)) self.point3.set_radius(self.staerke_linie) self.point3.set_facecolor(self.farbe_allgemein) self.point3.set_alpha(self.alpha_allgemein) self.parent.axes.add_patch(self.point3) self.point3.set_visible(False) 'Punkt4 instanziieren' self.point4 = Circle((self.xP4, self.yP4)) self.point4.set_radius(self.radius_punkt) self.point4.set_facecolor(self.farbe_allgemein) self.point4.set_alpha(self.alpha_allgemein) self.parent.axes.add_patch(self.point4) 'Punkt5 instanziieren' self.point5 = Circle((self.xP5, self.yP5)) self.point5.set_radius(self.radius_punkt) self.point5.set_facecolor(self.farbe_allgemein) self.point5.set_alpha(self.alpha_allgemein) self.parent.axes.add_patch(self.point5) self.point = self.point4 'Line2D-Objekte instanziieren' 'Endpunktkoordinaten von Linie1' #Linie1 - verbindet Punkt1 mit Punkt2 self.xL1 = (self.point1.center[0], self.point2.center[0]) self.yL1 = (self.point1.center[1], self.point2.center[1]) #Länge der Linie berechnen self.l1 = ((self.xL1[1] - self.xL1[0])**2 + (self.yL1[1] - \ self.yL1[0])**2)**(1/2) 'Linie1 instanziieren' self.line1 = Line2D(self.xL1, self.yL1) self.line1.set_linewidth(self.staerke_linie) self.line1.set_color(self.farbe_allgemein) self.line1.set_alpha(self.alpha_allgemein) self.line1.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.line1) 'Endpunktkoordinaten von Linie2' #Linie2 - verbindet Punkt2 mit Punkt3 self.xL2 = (self.point2.center[0], self.point3.center[0]) self.yL2 = (self.point2.center[1], self.point3.center[1]) #Länge der Linie berechnen self.l2 = ((self.xL2[1] - self.xL2[0])**2 + (self.yL2[1] - \ self.yL2[0])**2)**(1/2) 'Linie2 instanziieren' self.line2 = Line2D(self.xL2, self.yL2) self.line2.set_linewidth(self.staerke_linie) self.line2.set_color(self.farbe_allgemein) self.line2.set_alpha(self.alpha_allgemein) self.line2.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.line2) 'Endpunktkoordinaten von Linie3' #Linie3 - verbindet Punkt3 mit Punkt4 self.xL3 = (self.point3.center[0], self.point4.center[0]) self.yL3 = (self.point3.center[1], self.point4.center[1]) #Länge der Linie berechnen self.l3 = ((self.xL3[1] - self.xL3[0])**2 + (self.yL3[1] - \ self.yL3[0])**2)**(1/2) 'Linie3 instanziieren' self.line3 = Line2D(self.xL3, self.yL3) self.line3.set_linewidth(self.staerke_linie) self.line3.set_color(self.farbe_allgemein) self.line3.set_alpha(self.alpha_allgemein) self.line3.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.line3) 'Endpunktkoordinaten von Linie4' #Linie3 - verbindet Punkt4 mit Punkt5 self.xL4 = (self.point4.center[0], self.point5.center[0]) self.yL4 = (self.point4.center[1], self.point5.center[1]) #Länge der Linie berechnen self.l4 = ((self.xL4[1] - self.xL4[0])**2 + (self.yL4[1] - \ self.yL4[0])**2)**(1/2) 'Linie4 instanziieren' self.line4 = Line2D(self.xL4, self.yL4) self.line4.set_linewidth(self.staerke_linie) self.line4.set_color(self.farbe_allgemein) self.line4.set_alpha(self.alpha_allgemein) self.line4.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.line4) 'Geisterpunktobjekte instanziieren' 'Geisterpunkt2 instanziieren' self.pointG2 = Circle((self.xP2, self.yP2)) self.pointG2.set_radius(self.radius_punkt) self.pointG2.set_facecolor(self.farbe_allgemein) self.pointG2.set_alpha(self.alpha_geist) self.parent.axes.add_patch(self.pointG2) self.pointG2.set_visible(False) 'Geisterpunkt3 instanziieren' self.pointG3 = Circle((self.xP3, self.yP3)) self.pointG3.set_radius(self.staerke_linie) self.pointG3.set_facecolor(self.farbe_allgemein) self.pointG3.set_alpha(self.alpha_geist) self.parent.axes.add_patch(self.pointG3) self.pointG3.set_visible(False) 'Geisterpunkt4 instanziieren' self.pointG4 = Circle((self.xP4, self.yP4)) self.pointG4.set_radius(self.radius_punkt) self.pointG4.set_facecolor(self.farbe_punkt) self.pointG4.set_alpha(self.alpha_geist) self.parent.axes.add_patch(self.pointG4) self.pointG4.set_visible(False) 'Geisterpunkt5 instanziieren' self.pointG5 = Circle((self.xP5, self.yP5)) self.pointG5.set_radius(self.radius_punkt) self.pointG5.set_facecolor(self.farbe_punkt) self.pointG5.set_alpha(self.alpha_geist) self.parent.axes.add_patch(self.pointG5) self.pointG5.set_visible(False) 'Geisterlinienobjekte instanziieren' 'Geisterlinie1 instanziieren' self.lineG1 = Line2D(self.xL1, self.yL1) self.lineG1.set_linewidth(self.staerke_linie) self.lineG1.set_color(self.farbe_allgemein) self.lineG1.set_alpha(self.alpha_geist) self.lineG1.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.lineG1) self.lineG1.set_visible(False) 'Geisterlinie2 instanziieren' self.lineG2 = Line2D(self.xL2, self.yL2) self.lineG2.set_linewidth(self.staerke_linie) self.lineG2.set_color(self.farbe_allgemein) self.lineG2.set_alpha(self.alpha_geist) self.lineG2.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.lineG2) self.lineG2.set_visible(False) 'Geisterlinie3 instanziieren' self.lineG3 = Line2D(self.xL3, self.yL3) self.lineG3.set_linewidth(self.staerke_linie) self.lineG3.set_color(self.farbe_allgemein) self.lineG3.set_alpha(self.alpha_geist) self.lineG3.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.lineG3) self.lineG3.set_visible(False) 'Geisterlinie4 instanziieren' self.lineG4 = Line2D(self.xL4, self.yL4) self.lineG4.set_linewidth(self.staerke_linie) self.lineG4.set_color(self.farbe_allgemein) self.lineG4.set_alpha(self.alpha_geist) self.lineG4.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.lineG4) self.lineG4.set_visible(False) 'Attribut self.press' self.press = None 'Attribut self.background' self.background = None 'Aufruf der Methode connect' self.connect() '''Methode connect - Die Methode dient dem Verbinden der Events mit den entsprechenden Methoden. Beim Drücken der linken Maustaste, dem button_ press_event, wird die Methode on_press ausgeführt. Weiter führt das Loslassen der linken Maustaste, dem button_release_event, zum Ausführen der Methode on_release. Zuletzt wird bei der Bewegung der Maus, dem motion_notify_event, die Methode on_motion aufgerufen. Vorraussetzung für ein Event ist das Drücken oder Loslassen der linken Maustaste auf oder das Bewegen der Maus über die Zeichenfläche.''' def connect(self): 'Verbindet das button_press_event mit der Methode on_press' self.cidpress = self.point.figure.canvas.mpl_connect( 'button_press_event', self.on_press) 'Verbindet das button_release_event mit der Methode on_release' self.cidrelease = self.point.figure.canvas.mpl_connect( 'button_release_event', self.on_release) 'Verbindet das motion_notify_event mit der Methode on_motion' self.cidmotion = self.point.figure.canvas.mpl_connect( 'motion_notify_event', self.on_motion) '''Methode on_press - Die Methode on_press wird beim Drücken der linken Maustaste auf der Zeichenfläche ausgeführt.''' def on_press(self, event): '''Die Methode wird weiter ausgeführt wenn der Mauszeiger zum Zeitpunkt des Drückens der linken Maustaste innerhalb des Koordinatensystems liegt.''' if event.inaxes != self.point.axes: return '''Die Methode wird weiter ausgeführt wenn vor dem Drücken der linken Maustaste kein Circle-Objekt ausgewählt ist.''' if SeitenansichtRoboter.lock is not None: return 'Fallunterscheidung - Punkt4 oder Punkt5' if self.point4.contains(event)[0] == True: self.point = self.point4 elif self.point5.contains(event)[0] == True: self.point = self.point5 contains, attrd = self.point.contains(event) '''Die Methode wird weiter ausgeführt wenn der Mauszeiger zum Zeitpunkt des Drückens der linken Maustaste auf dem bewegbaren Circle-Objekt liegt.''' if not contains: return '''Den Mittelpunkt des Circle-Objektes und die x- und y-Koordinaten des Mauszeigers zum Zeitpunkt des Drückens der linken Maustaste speichern.''' self.press = self.point.center, event.xdata, event.ydata 'Das Klassenattribut mit dem Wert self belegen.' SeitenansichtRoboter.lock = self 'Sichtbarkeit des Geistes ändern' self.pointG2.set_visible(True) self.pointG4.set_visible(True) self.pointG5.set_visible(True) self.lineG1.set_visible(True) self.lineG2.set_visible(True) self.lineG3.set_visible(True) self.lineG4.set_visible(True) 'Methoden der Animation-Blit-Technik ausführen' canvas = self.point.figure.canvas axes = self.point.axes self.point2.set_animated(True) self.point3.set_animated(True) self.point4.set_animated(True) self.point5.set_animated(True) self.line1.set_animated(True) self.line2.set_animated(True) self.line3.set_animated(True) self.line4.set_animated(True) canvas.draw() self.background = canvas.copy_from_bbox(self.point.axes.bbox) axes.draw_artist(self.point2) axes.draw_artist(self.point3) axes.draw_artist(self.point4) axes.draw_artist(self.point5) axes.draw_artist(self.line1) axes.draw_artist(self.line2) axes.draw_artist(self.line3) axes.draw_artist(self.line4) canvas.blit(axes.bbox) '''Methode on_motion - Die Methode on_motion wird beim Bewegen des Mauszeigers über die Zeichenfläche ausgeführt.''' def on_motion(self, event): '''Die Methode wird weiter ausgeführt wenn das Klassenattribut mit dem Wert self belegt ist. Das Circle-Objekt darf ohne angeklickt zu sein nicht bewegt werden.''' if SeitenansichtRoboter.lock is not self: return '''Die Methode wird weiter ausgeführt wenn der Mauszeiger innerhalb des Koordinatensystems bewegt wird.''' if event.inaxes != self.point.axes: return '''Den Mittelpunkt des Circle-Objektes und die x- und y-Koordinaten des Mauszeigers zum Zeitpunkt des Drückens der linken Maustaste zuweisen.''' self.point.center, xpress, ypress = self.press 'Fallunterscheidung - Punkt4 oder Punkt5' if self.point == self.point4: 'Verschiebung von Punkt4 in x-, und y-Richtung' dx = event.xdata - xpress dy = event.ydata - ypress 'neue Koordinaten berechnen' x_neu = self.point.center[0] + dx y_neu = self.point.center[1] + dy 'Begrenzung auf [x_min,...[ und [y_min...[' if x_neu < self.x_min and dx < 0: x_neu = self.x_min if y_neu < self.y_min and dy < 0: y_neu = self.y_min 'Länge des Ortsvektors zu Punkt4 berechnen' self.r4 = (x_neu**2 + y_neu**2)**(1 / 2) 'Hilfswinkel berechnen - Cosinussatz' b = (self.a3**2 - self.l1**2 - self.r4**2) / (-2 * self.l1 * self.r4) if b >= 1: b = 1 elif b <= -1: b = -1 beta1 = acos(b) beta2 = acos(x_neu / self.r4) 'Winkel von Punkt2 berechnen' self.phi2 = beta1 + beta2 'Winkel auf [0, 2*pi] normieren um Rundungsfehler auszugleichen' self.phi2 = winkel_normieren(self.phi2) 'Winkelgrenzen zuweisen' phi2_min = self.theta2_min phi2_max = self.theta2_max 'Winkelbegrenzung [phi_min, phi_max]' if self.phi2 < phi2_min: self.phi2 = phi2_min elif self.phi2 > phi2_max: self.phi2 = phi2_max 'Theta2 (Denavit-Hartenberg-Parameter) aktualisieren' self.theta2 = self.phi2 'Hilfswinkel berechnen - Cosinussatz' b = (self.r4**2 - self.l1**2 - self.a3**2) / (-2 * self.l1 * self.a3) if b >= 1: b = 1 elif b <= -1: b = -1 beta3 = acos(b) 'Winkelgrenzen zuweisen' beta3_min = self.theta3_min + pi beta3_max = self.theta3_max + pi 'Winkelbegrenzung [phi_min, phi_max]' if beta3 < beta3_min: beta3 = beta3_min elif beta3 > beta3_max: beta3 = beta3_max 'Winkel von Punkt4 berechnen' self.phi4 = beta3 - (pi - self.phi2) 'Theta3 (Denavit-Hartenberg-Parameter) berechnen' self.theta3 = -(pi - beta3) 'Winkel von Punkt3 berechnen' self.phi3 = self.phi4 + pi / 4 - 8 * pi / 180 'Winkel auf [0, 2*pi] normieren um Rundungsfehler auszugleichen' self.phi3 = winkel_normieren(self.phi3) 'Mittelpunktkoordinaten der Circle-Objekte aktualisieren' 'Koordinaten von Punkt2' self.xP2 = self.l1 * cos(self.phi2) self.yP2 = self.l1 * sin(self.phi2) 'Koordinaten akualisieren' self.point2.center = ((self.xP2, self.yP2)) 'Koordinaten von Punkt3' self.xP3 = self.point2.center[0] + self.l2 * cos(self.phi3) self.yP3 = self.point2.center[1] + self.l2 * sin(self.phi3) 'Koordinaten akualisieren' self.point3.center = ((self.xP3, self.yP3)) 'Koordinaten von Punkt4' self.xP4 = self.point2.center[0] + self.a3 * cos(self.phi4) self.yP4 = self.point2.center[1] + self.a3 * sin(self.phi4) 'Koordinaten akualisieren' self.point4.center = ((self.xP4, self.yP4)) elif self.point == self.point5: 'relative Verschiebung' dx = self.point5.center[0] - self.point4.center[0] dy = self.point5.center[1] - self.point4.center[1] 'Winkel berechnen - Kreismittelpunkt' phi = winkel_berechnen(dx, dy) 'relative Verschiebung' dx_p = xpress - self.point4.center[0] dy_p = ypress - self.point4.center[1] 'Winkel berechnen - Mauszeiger beim Anklicken des Punktes' phi_p = winkel_berechnen(dx_p, dy_p) 'relative Verschiebung' dx_e = event.xdata - self.point4.center[0] dy_e = event.ydata - self.point4.center[1] 'Winkel berechnen - Mauszeiger bei der Bewegung' phi_e = winkel_berechnen(dx_e, dy_e) 'Winkeländerung berechnen' dphi = phi_e - phi_p 'neuen Positionswinkel berechnen' phi_neu = phi + dphi 'Winkel auf [0, 2*pi] normieren um Rundungsfehler auszugleichen' phi_neu = winkel_normieren(phi_neu) 'Winkel von Punkt5 berechnen' self.phi5 = phi_neu 'Winkelgrenzen - senkrechter Anschlag' if self.phi5 > pi / 2 and self.phi5 < pi: self.phi5 = pi / 2 elif self.phi5 >= pi and self.phi5 < 3 * pi / 2: self.phi5 = 3 * pi / 2 'Winkelgrenzen - rechtwinkeliger Anschlag' phi5_min = self.phi4 - 8 * pi / 180 + 3 * pi / 2 phi5_max = self.phi4 - 8 * pi / 180 + pi / 2 'Winkelbegrenzung [phi_min, phi_max]' if self.phi5 >= pi and self.phi5 < phi5_min: self.phi5 = phi5_min elif self.phi5 > phi5_max and self.phi5 < pi: self.phi5 = phi5_max 'Theta4 (Denavit-Hartenberg-Parameter) aktualisieren' if self.phi5 >= 0 and self.phi5 <= pi / 2: self.theta4 = pi / 2 - self.phi4 + self.phi5 elif self.phi5 >= 3 * pi / 2 and self.phi5 < 2 * pi: self.theta4 = pi / 2 - self.phi4 + self.phi5 - 2 * pi 'Koordinaten von Punkt5' self.xP5 = self.point4.center[0] + self.l4 * cos(self.phi5) self.yP5 = self.point4.center[1] + self.l4 * sin(self.phi5) 'Koordinaten akualisieren' self.point5.center = ((self.xP5, self.yP5)) 'Endpunktkoordinaten der Line2D-Objekte aktualisieren' 'Koordinaten von Linie1' self.xL1 = (self.point1.center[0], self.point2.center[0]) self.yL1 = (self.point1.center[1], self.point2.center[1]) 'Koordinaten akualisieren' self.line1.set_data(self.xL1, self.yL1) 'Koordinaten von Linie2' self.xL2 = (self.point2.center[0], self.point3.center[0]) self.yL2 = (self.point2.center[1], self.point3.center[1]) 'Koordinaten akualisieren' self.line2.set_data(self.xL2, self.yL2) 'Koordinaten von Linie3' self.xL3 = (self.point3.center[0], self.point4.center[0]) self.yL3 = (self.point3.center[1], self.point4.center[1]) 'Koordinaten akualisieren' self.line3.set_data(self.xL3, self.yL3) 'Koordinaten von Linie4' self.xL4 = (self.point4.center[0], self.point5.center[0]) self.yL4 = (self.point4.center[1], self.point5.center[1]) 'Koordinaten akualisieren' self.line4.set_data(self.xL4, self.yL4) 'Methoden der Animation-Blit-Technik ausführen' canvas = self.point.figure.canvas axes = self.point.axes canvas.restore_region(self.background) axes.draw_artist(self.point2) axes.draw_artist(self.point3) axes.draw_artist(self.point4) axes.draw_artist(self.point5) axes.draw_artist(self.line1) axes.draw_artist(self.line2) axes.draw_artist(self.line3) axes.draw_artist(self.line4) canvas.blit(axes.bbox) 'Signal mit den neuen Koordinaten senden' self.xy_neu.emit(self.xP2, self.yP2, self.xP3, self.yP3, \ self.xP4, self.yP4, self.xP5, self.yP5) '''Methode on_release - Die Methode on_release wird beim Loslassen der linken Maustaste auf der Zeichenfläche ausgeführt.''' def on_release(self, event): '''Die Methode wird weiter ausgeführt wenn das Klassenattribut mit dem Wert self belegt ist.''' if SeitenansichtRoboter.lock is not self: return 'Werte der Attribute zurücksetzen' self.press = None SeitenansichtRoboter.lock = None 'Attribute auf False setzen' self.point2.set_animated(False) self.point3.set_animated(False) self.point4.set_animated(False) self.point5.set_animated(False) self.line1.set_animated(False) self.line2.set_animated(False) self.line3.set_animated(False) self.line4.set_animated(False) 'Hintergrund zurücksetzen' self.background = None 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw() '''Methode ansicht_aktualisieren - Die Methode ermöglicht das Aktualisieren der Ansicht.''' def ansicht_aktualisieren(self, xP2, yP2, xP3, yP3, xP4, yP4, xP5, yP5): 'Zeichenwinkel berechnen' self.modellrechnung(xP2, yP2, xP3, yP3, xP4, yP4, xP5, yP5) 'Mittelpunktkoordinaten der Circle-Objekte aktualisieren' 'Koordinaten von Punkt2 aktualisieren' self.point2.center = (self.xP2, self.yP2) 'Koordinaten von Punkt3 aktualisieren' self.point3.center = (self.xP3, self.yP3) 'Koordinaten von Punkt4 aktualisieren' self.point4.center = (self.xP4, self.yP4) 'Koordinaten von Punkt5 aktualisieren' self.point5.center = (self.xP5, self.yP5) 'Endpunktkoordinaten der Line2D-Objekte aktualisieren' 'Koordinaten von Linie1' self.xL1 = (self.point1.center[0], self.point2.center[0]) self.yL1 = (self.point1.center[1], self.point2.center[1]) 'Koordinaten aktualisieren' self.line1.set_data(self.xL1, self.yL1) 'Koordinaten von Linie2' self.xL2 = (self.point2.center[0], self.point3.center[0]) self.yL2 = (self.point2.center[1], self.point3.center[1]) 'Koordinaten aktualisieren' self.line2.set_data(self.xL2, self.yL2) 'Koordinaten von Linie3' self.xL3 = (self.point3.center[0], self.point4.center[0]) self.yL3 = (self.point3.center[1], self.point4.center[1]) 'Koordinaten aktualisieren' self.line3.set_data(self.xL3, self.yL3) 'Koordinaten von Linie4' self.xL4 = (self.point4.center[0], self.point5.center[0]) self.yL4 = (self.point4.center[1], self.point5.center[1]) 'Koordinaten aktualisieren' self.line4.set_data(self.xL4, self.yL4) 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw() '''Methode geisterstunde - Die Methode dient dem Ein- oder Ausblenden des Geistes. Weiter werden die Koordinaten aktualisiert.''' def geisterstunde(self, b): 'Mittelpunktkoordinaten der Circle-Objekte aktualisieren' 'Koordinaten von Geisterpunkt2' xGp2 = self.point2.center[0] yGp2 = self.point2.center[1] 'Koordinaten aktualisieren' self.pointG2.center = (xGp2, yGp2) 'Koordinaten von Geisterpunkt3' xGp3 = self.point3.center[0] yGp3 = self.point3.center[1] 'Koordinaten aktualisieren' self.pointG3.center = (xGp3, yGp3) 'Koordinaten von Geisterpunkt4' xGp4 = self.point4.center[0] yGp4 = self.point4.center[1] 'Koordinaten aktualisieren' self.pointG4.center = (xGp4, yGp4) 'Koordinaten von Geisterpunkt5' xGp5 = self.point5.center[0] yGp5 = self.point5.center[1] self.pointG5.center = (xGp5, yGp5) 'Endpunktkoordinaten der Line2D-Objekte aktualisieren' 'Koordinaten von Geisterlinie1' xGl1 = (self.point1.center[0], self.point2.center[0]) yGl1 = (self.point1.center[1], self.point2.center[1]) 'Koordinaten akualisieren' self.lineG1.set_data(xGl1, yGl1) 'Koordinaten von Geisterlinie2' xGl2 = (self.point2.center[0], self.point3.center[0]) yGl2 = (self.point2.center[1], self.point3.center[1]) 'Koordinaten akualisieren' self.lineG2.set_data(xGl2, yGl2) 'Koordinaten von Geisterlinie3' xGl3 = (self.point3.center[0], self.point4.center[0]) yGl3 = (self.point3.center[1], self.point4.center[1]) 'Koordinaten akualisieren' self.lineG3.set_data(xGl3, yGl3) 'Koordinaten von Geisterlinie4' xGl4 = (self.point4.center[0], self.point5.center[0]) yGl4 = (self.point4.center[1], self.point5.center[1]) 'Koordinaten akualisieren' self.lineG4.set_data(xGl4, yGl4) 'Sichtbarkeit des Geistes ändern' #Sichtbarkeit ändern - True oder False self.pointG2.set_visible(b) self.pointG4.set_visible(b) self.pointG5.set_visible(b) self.lineG1.set_visible(b) self.lineG2.set_visible(b) self.lineG3.set_visible(b) self.lineG4.set_visible(b) 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw() '''Methode modellrechnung - Die Punkte werden als Vektorzug gezeichnet. Die Methode berechnet die zum Zeichnen notwendigen Winkel der vier Punkte.''' def modellrechnung(self, xP2, yP2, xP3, yP3, xP4, yP4, xP5, yP5): 'Kartesische Koordinaten' 'Punkt2, Punkt3, Punkt4 und Punkt5' self.xP2 = xP2 self.yP2 = yP2 self.xP3 = xP3 self.yP3 = yP3 self.xP4 = xP4 self.yP4 = yP4 self.xP5 = xP5 self.yP5 = yP5 'Länge des Ortsvektors zu Punkt4 berechnen' self.r4 = (self.xP4**2 + self.yP4**2)**(1 / 2) 'Hilfswinkel berechnen - Cosinussatz' b = (self.a3**2 - self.a2**2 - self.r4**2) / (-2 * self.a2 * self.r4) if b >= 1: b = 1 elif b <= -1: b = -1 beta1 = acos(b) beta2 = acos(self.xP4 / self.r4) 'Winkel von Punkt2 berechnen' self.phi2 = beta1 + beta2 'Winkel auf [0, 2*pi] normieren um Rundungsfehler auszugleichen' self.phi2 = winkel_normieren(self.phi2) 'Theta2 (Denavit-Hartenberg-Parameter) berechnen' self.theta2 = self.phi2 'Hilfswinkel berechnen - Cosinussatz' b = (self.r4**2 - self.a2**2 - self.a3**2) / (-2 * self.a2 * self.a3) if b >= 1: b = 1 elif b <= -1: b = -1 beta3 = acos(b) 'Winkel von Punkt4 berechnen' self.phi4 = beta3 - (pi - self.phi2) 'Theta3 (Denavit-Hartenberg-Parameter) berechnen' self.theta3 = -(pi - beta3) 'Winkel von Punkt3 berechnen' self.phi3 = self.phi4 + pi / 4 - 8 * pi / 180 'Winkel auf [0, 2*pi] normieren um Rundungsfehler auszugleichen' self.phi3 = winkel_normieren(self.phi3) 'Verschiebung von Punkt5 relativ zu Punkt4' dx = self.xP5 - self.xP4 dy = self.yP5 - self.yP4 'Winkel von Punkt5 berechnen' self.phi5 = winkel_berechnen(dx, dy) 'Winkel normieren' self.phi5 = winkel_normieren(self.phi5) 'Theta4 (Denavit-Hartenberg-Parameter) berechnen' if self.phi5 >= 0 and self.phi5 <= pi / 2: self.theta4 = self.phi5 + pi / 2 - 8 * pi / 180 elif self.phi5 >= 3 * pi / 2 and self.phi5 < 2 * pi: self.theta4 = pi / 2 - 8 * pi / 180 - 2 * pi + self.phi5 '''Methode punkte_faerben - Die Methode färbt oder entfärbt die bewegbaren Circle-Objekte.''' def punkte_faerben(self, b): 'Fallunterscheidung' if b == True: #Farbe farbe = self.farbe_punkt elif b == False: #Schwarz farbe = self.farbe_allgemein 'Farbe von Punkt4 und Punkt 5 festlegen' self.point4.set_facecolor(farbe) self.point5.set_facecolor(farbe) 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw()
vx2 = vx / vn vy2 = vy / vn print Ur1, -vx2, -vy2 x[i] = x[i - 1] - zeta * vx2 y[i] = y[i - 1] - zeta * vy2 """ell = Ellipse((3.0, 4.0), 2, 4, 0) a = plt.subplot(111, aspect='equal') ell.set_alpha(0.1) a.add_artist(ell)""" c1 = Circle((2.5, 4.25), 2) # he has a third number. do we need a third number? c2 = Circle((7.5, 4.5), 1.8) c3 = Circle((8.5, 8.5), 0.4) a = plt.subplot(111, aspect="equal") # assuming 111 makes it grey colored? c1.set_alpha(0.1) a.add_artist(c1) c2.set_alpha(0.1) a.add_artist(c2) c3.set_alpha(0.1) a.add_artist(c3) plt.plot(x, y, "b.") plt.xlabel("X") plt.ylabel("Y") plt.title("Path") plt.show()
def gen_png(*args): if len(args) == 1: if len(args[0]) == 4: res = args[0][0] f_name = args[0][1] extension = args[0][2] header_lines = args[0][3] elif len(args) == 4: res = args[0] f_name = args[1] extension = args[2] header_lines = args[3] else: print "Wrong number or type of arguments, aborting" return (-1) data = np.loadtxt(f_name+extension, skiprows=header_lines) header = np.genfromtxt(f_name+extension, max_rows=4) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') global t t += header[-1] dt = header[-1] to_delete = [] for i in range(0, data.shape[0]): if (data[i,1] < 0 and data[i,0] >0): to_delete.append(i) data = np.delete(data, to_delete, axis=0) rho = data[::res,-2] norm_rho = np.zeros(rho.shape) # print np.amin(rho), np.amax(rho) for i in range(0, np.shape(rho)[0]): norm_rho[i] = (rho[i]-np.amin(rho))/(np.amax(rho)-np.amin(rho)) # print np.amin(rho), np.amax(rho), rho # print np.amin(norm_rho), np.amax(norm_rho), norm_rho norm = LogNorm(vmin=np.amin(rho), vmax=np.amax(rho), clip=False) radius = np.amax(data[::res,2]) circle1 = Circle((0,0), radius) circle1.set_fill(True) circle1.set_edgecolor('red') circle1.set_fc('grey') circle1.set_alpha(0.5) ax.add_patch(circle1) art3d.pathpatch_2d_to_3d(circle1, z=0, zdir="y") s = ax.scatter(data[::res,0], data[::res,1], data[::res,2], norm=norm, cmap='hot', c=rho, marker='.') ax.text2D(0.05, 0.95, '{} myr; {} myr'.format(t,dt), transform=ax.transAxes) ax.set_ylim(ax.get_xlim()) ax.set_xlabel('x') ax.set_ylabel('y') ax.set_zlabel('z') fig.colorbar(s, shrink=0.5, aspect=5) # circle2 = Circle((0,0), radius) # circle2.set_fill(False) # circle2.set_edgecolor('red') # ax.add_patch(circle2) # art3d.pathpatch_2d_to_3d(circle2, z=0, zdir="x") plt.savefig(f_name+'.png', dpi=300, papertype='a4') #plt.show() plt.close(fig) return (f_name, 0)
import random import csv with open('labels-simple.csv', 'w', newline='') as file: writer = csv.writer(file) writer.writerow(["Filename", "i", "x", "y", "r"]) for i in range(400): if i % 100 == 0: print(i) fig = plt.figure() x = random.uniform(.2, .8) y = random.uniform(.2, .8) r = random.uniform(.2, .8) name = "circleixyr_{}_{:.3f}_{:.3f}_{:.3f}".format(i, x, y, r) e = Circle(xy=(x, y), radius=r) ax = plt.gca() # ax = subplot( 1,1,1 ) ax.add_artist(e) #print(ax.bbox) bb = ax.bbox bb._bbox = Bbox(np.array([[0.0, 0.0], [1.0, 1.0]], float)) e.set_clip_box(ax.bbox) e.set_edgecolor("black") e.set_facecolor("none") # "none" not None e.set_alpha(1) plt.axis('off') base = '/data/mialab/users/washbee/circles-simple/' plt.savefig("{}{}.jpg".format(base, name), bbox_inches='tight') plt.close(fig) writer.writerow(["{}{}.jpg".format(base, name), i, x, y, r])
class RueckansichtGreifer(QObject): 'Signal definieren' xy_neu = Signal(float, float, float, float) 'Klassenattribut lock definieren' lock = None 'Methode __init__' def __init__(self, parent, xP6, yP6, xP7, yP7): 'Vererbung aller Attribute und Methoden von QObject' super(RueckansichtGreifer, self).__init__(parent) 'Parentobjekt - QPlotWidget' self.parent = parent 'Umrechnung in Polarkoordinaten' self.modellrechnung(xP6, yP6, xP7, yP7) 'Grenzradien festlegen' self.r_min = 100 self.r_max = 200 'Grenzwinkel festlegen' self.phi6_min = 0 self.phi6_max = pi 'Farben der Punkte und Linien festlegen' self.farbe_allgemein = 'black' self.farbe_punkt = '#5c061c' self.alpha_allgemein = 0.5 self.alpha_geist = 0.25 'Punktradius, Linienstärke und Linienende festlegen' self.radius_punkt = 55 self.staerke_linie = 20 self.ende_linie = 'round' 'Circle-Objekte instanziieren' 'Punkt6 instanziieren' self.point6 = Circle((self.xP6, self.yP6)) self.point6.set_radius(self.radius_punkt) self.point6.set_facecolor(self.farbe_allgemein) self.point6.set_alpha(self.alpha_allgemein) self.parent.axes.add_patch(self.point6) 'Punkt7 instanziieren' self.point7 = Circle((self.xP7, self.yP7)) self.point7.set_radius(self.radius_punkt) self.point7.set_facecolor(self.farbe_allgemein) self.point7.set_alpha(self.alpha_allgemein) self.parent.axes.add_patch(self.point7) self.point = self.point6 'Line2D-Objekte instanziieren' 'Endpunktkoordinaten von Linie1' #Linie1 - verbindet den Ursprung mit Punkt6 self.xL1 = (0, self.xP6) self.yL1 = (0, self.yP6) 'Linie1 instanziieren' self.line1 = Line2D(self.xL1, self.yL1) self.line1.set_linewidth(self.staerke_linie) self.line1.set_color(self.farbe_allgemein) self.line1.set_alpha(self.alpha_allgemein) self.line1.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.line1) 'Endpunktkoordinaten von Linie2' #Linie1 - verbindet den Ursprung mit Punkt7 self.xL2 = (0, self.xP7) self.yL2 = (0, self.yP7) 'Linie2 instanziieren' self.line2 = Line2D(self.xL2, self.yL2) self.line2.set_linewidth(self.staerke_linie) self.line2.set_color(self.farbe_allgemein) self.line2.set_alpha(self.alpha_allgemein) self.line2.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.line2) 'Geisterpunktobjekte instanziieren' 'Geisterpunkt6 instanziieren' self.pointG6 = Circle((self.xP6, self.yP6)) self.pointG6.set_radius(self.radius_punkt) self.pointG6.set_facecolor(self.farbe_punkt) self.pointG6.set_alpha(self.alpha_geist) self.parent.axes.add_patch(self.pointG6) self.pointG6.set_visible(False) 'Geisterpunkt7 instanziieren' self.pointG7 = Circle((self.xP7, self.yP7)) self.pointG7.set_radius(self.radius_punkt) self.pointG7.set_facecolor(self.farbe_allgemein) self.pointG7.set_alpha(self.alpha_geist) self.parent.axes.add_patch(self.pointG7) self.pointG7.set_visible(False) 'Geisterlinienobjekte instanziieren' 'Geisterlinie1 instanziieren' self.lineG1 = Line2D(self.xL1, self.yL1) self.lineG1.set_linewidth(self.staerke_linie) self.lineG1.set_color(self.farbe_allgemein) self.lineG1.set_alpha(self.alpha_geist) self.lineG1.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.lineG1) self.lineG1.set_visible(False) 'Geisterlinie2 instanziieren' self.lineG2 = Line2D(self.xL2, self.yL2) self.lineG2.set_linewidth(self.staerke_linie) self.lineG2.set_color(self.farbe_allgemein) self.lineG2.set_alpha(self.alpha_geist) self.lineG2.set_solid_capstyle(self.ende_linie) self.parent.axes.add_line(self.lineG2) self.lineG2.set_visible(False) 'Attribut self.press' self.press = None 'Attribut self.background' self.background = None 'Aufruf der Methode connect' self.connect() '''Methode connect - Die Methode dient dem Verbinden der Events mit den entsprechenden Methoden. Beim Drücken der linken Maustaste, dem button_ press_event, wird die Methode on_press ausgeführt. Weiter führt das Loslassen der linken Maustaste, dem button_release_event, zum Ausführen der Methode on_release. Zuletzt wird bei der Bewegung der Maus, dem motion_notify_event, die Methode on_motion aufgerufen. Vorraussetzung für ein Event ist das Drücken oder Loslassen der linken Maustaste auf oder das Bewegen der Maus über die Zeichenfläche.''' def connect(self): 'Verbindet das button_press_event mit der Methode on_press' self.cidpress = self.point.figure.canvas.mpl_connect( 'button_press_event', self.on_press) 'Verbindet das button_release_event mit der Methode on_release' self.cidrelease = self.point.figure.canvas.mpl_connect( 'button_release_event', self.on_release) 'Verbindet das motion_notify_event mit der Methode on_motion' self.cidmotion = self.point.figure.canvas.mpl_connect( 'motion_notify_event', self.on_motion) '''Methode on_press - Die Methode on_press wird beim Drücken der linken Maustaste auf der Zeichenfläche ausgeführt.''' def on_press(self, event): '''Die Methode wird weiter ausgeführt wenn der Mauszeiger zum Zeitpunkt des Drückens der linken Maustaste innerhalb des Koordinatensystems liegt.''' if event.inaxes != self.point.axes: return '''Die Methode wird weiter ausgeführt wenn vor dem Drücken der linken Maustaste kein Circle-Objekt ausgewählt ist.''' if RueckansichtGreifer.lock is not None: return contains, attrd = self.point.contains(event) '''Die Methode wird weiter ausgeführt wenn der Mauszeiger zum Zeitpunkt des Drückens der linken Maustaste auf dem bewegbaren Circle-Objekt liegt.''' if not contains: return '''Den Mittelpunkt des Circle-Objektes und die x- und y-Koordinaten des Mauszeigers zum Zeitpunkt des Drückens der linken Maustaste speichern.''' self.press = self.point.center, event.xdata, event.ydata 'Das Klassenattribut mit dem Wert self belegen.' RueckansichtGreifer.lock = self 'Sichtbarkeit des Geistes ändern' self.pointG6.set_visible(True) self.pointG7.set_visible(True) self.lineG1.set_visible(True) self.lineG2.set_visible(True) 'Methoden der Animation-Blit-Technik ausführen' canvas = self.point.figure.canvas axes = self.point.axes self.point6.set_animated(True) self.point7.set_animated(True) self.line1.set_animated(True) self.line2.set_animated(True) canvas.draw() self.background = canvas.copy_from_bbox(self.point.axes.bbox) axes.draw_artist(self.point6) axes.draw_artist(self.point7) axes.draw_artist(self.line1) axes.draw_artist(self.line2) canvas.blit(axes.bbox) '''Methode on_motion - Die Methode on_motion wird beim Bewegen des Mauszeigers über die Zeichenfläche ausgeführt.''' def on_motion(self, event): '''Die Methode wird weiter ausgeführt wenn das Klassenattribut mit dem Wert self belegt ist. Das Circle-Objekt darf ohne angeklickt zu sein nicht bewegt werden.''' if RueckansichtGreifer.lock is not self: return '''Die Methode wird weiter ausgeführt wenn der Mauszeiger innerhalb des Koordinatensystems bewegt wird.''' if event.inaxes != self.point.axes: return '''Den Mittelpunkt des Circle-Objektes und die x- und y-Koordinaten des Mauszeigers zum Zeitpunkt des Drückens der linken Maustaste zuweisen.''' self.point.center, xpress, ypress = self.press 'Radien aller Circle-Objekte neu berechnen' 'Verschiebung von Punkt6 in x- und y-Richtung' dx = event.xdata - xpress dy = event.ydata - ypress 'neue Koordinaten berechnen' x_neu = self.point.center[0] + dx y_neu = self.point.center[1] + dy 'neuen Radius berechnen' r_neu = (x_neu**2 + y_neu**2)**(1/2) 'Radiusbegrenzung [r_min, r_max]' if r_neu <= self.r_min: r_neu = self.r_min elif r_neu >= self.r_max: r_neu = self.r_max 'Radien aktualisieren' self.r6 = r_neu self.r7 = self.r6 'Winkel aller Circle-Objekte neu berechnen' 'Winkel berechnen - Kreismittelpunkt' phi = winkel_berechnen(self.point.center[0], self.point.center[1]) 'Winkel berechnen - Mauszeiger beim Anklicken des Punktes' phi_p = winkel_berechnen(xpress, ypress) 'Winkel berechnen - Mauszeiger bei der Bewegung' phi_e = winkel_berechnen(event.xdata, event.ydata) 'Winkeländerung berechnen' dphi = phi_e - phi_p 'neuen Positionswinkel berechnen' phi_neu = phi + dphi 'Winkel auf [0, 2*pi] normieren um Rundungsfehler auszugleichen' phi_neu = winkel_normieren(phi_neu) 'Winkel von Punkt6 aktualisieren' self.phi6 = phi_neu 'Winkelbegrenzung [phi_min, phi_max]' if self.phi6 < self.phi6_min or self.phi6 > 3*pi/2 and \ self.phi6 < 2*pi: self.phi6 = self.phi6_min elif self.phi6 > self.phi6_max and self.phi6 < 3*pi/2: self.phi6 = self.phi6_max 'Winkel von Punkt7 aktualisieren' self.phi7 = self.phi6 + pi 'Winkel auf [0, 2*pi] normieren um Rundungsfehler auszugleichen' self.phi7 = winkel_normieren(self.phi7) 'Theta5 (Denavit-Hartenberg-Parameter) aktualisieren' self.theta5 = pi - self.phi6 'Mittelpunktkoordinaten der Circle-Objekte aktualisieren' 'Koordinaten von Punkt6' self.xP6 = self.r6*cos(self.phi6) self.yP6 = self.r6*sin(self.phi6) 'Koordinaten akualisieren' self.point6.center = ((self.xP6, self.yP6)) 'Koordinaten von Punkt7' self.xP7 = self.r7*cos(self.phi7) self.yP7 = self.r7*sin(self.phi7) 'Koordinaten akualisieren' self.point7.center = ((self.xP7, self.yP7)) 'Endpunktkoordinaten der Line2D-Objekte aktualisieren' 'Koordinaten von Linie1' self.xL1 = (0, self.xP6) self.yL1 = (0, self.yP6) 'Koordinaten akualisieren' self.line1.set_data(self.xL1, self.yL1) 'Koordinaten von Linie2' self.xL2 = (0, self.xP7) self.yL2 = (0, self.yP7) 'Koordinaten akualisieren' self.line2.set_data(self.xL2, self.yL2) 'Methoden der Animation-Blit-Technik ausführen' canvas = self.point.figure.canvas axes = self.point.axes canvas.restore_region(self.background) axes.draw_artist(self.point6) axes.draw_artist(self.point7) axes.draw_artist(self.line1) axes.draw_artist(self.line2) canvas.blit(axes.bbox) 'Signal mit den neuen Koordinaten senden' self.xy_neu.emit(self.xP6, self.yP6, self.xP7, self.yP7) '''Methode on_release - Die Methode on_release wird beim Loslassen der linken Maustaste auf der Zeichenfläche ausgeführt.''' def on_release(self, event): '''Die Methode wird weiter ausgeführt wenn das Klassenattribut mit dem Wert self belegt ist.''' if RueckansichtGreifer.lock is not self: return 'Werte der Attribute zurücksetzen' self.press = None RueckansichtGreifer.lock = None 'Attribute auf False setzen' self.point6.set_animated(False) self.point7.set_animated(False) self.line1.set_animated(False) self.line2.set_animated(False) 'Hintergrund zurücksetzen' self.background = None 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw() '''Methode ansicht_aktualisieren - Die Methode ermöglicht das Aktualisieren der Ansicht.''' def ansicht_aktualisieren(self, xP6, yP6, xP7, yP7): 'Umrechnung in Polarkoordinaten' self.modellrechnung(xP6, yP6, xP7, yP7) 'Mittelpunktkoordinaten der Circle-Objekte aktualisieren' 'Koordinaten von Punkt6 aktualisieren' self.point6.center = ((self.xP6, self.yP6)) 'Koordinaten von Punkt7 aktualisieren' self.point7.center = ((self.xP7, self.yP7)) 'Endpunktkoordinaten der Line2D-Objekte aktualisieren' 'Koordinaten von Linie1' self.xL1 = (0, self.xP6) self.yL1 = (0, self.yP6) 'Koordinaten aktualisieren' self.line1.set_data(self.xL1, self.yL1) 'Koordinaten von Linie2' self.xL2 = (0, self.xP7) self.yL2 = (0, self.yP7) 'Koordinaten aktualisieren' self.line2.set_data(self.xL2, self.yL2) 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw() '''Methode geisterstunde - Die Methode dient dem Ein- oder Ausblenden des Geistes. Weiter werden die Koordinaten aktualisiert.''' def geisterstunde(self, b): 'Mittelpunktkoordinaten der Circle-Objekte aktualisieren' 'Koordinaten von Geisterpunkt6' xGp6 = self.point6.center[0] yGp6 = self.point6.center[1] 'Koordinaten aktualisieren' self.pointG6.center = (xGp6, yGp6) 'Koordinaten von Geisterpunkt7' xGp7 = self.point7.center[0] yGp7 = self.point7.center[1] 'Koordinaten aktualisieren' self.pointG7.center = (xGp7, yGp7) 'Endpunktkoordinaten der Line2D-Objekte aktualisieren' 'Koordinaten von Geisterlinie1' xGl1 = (0, self.xP6) yGl1 = (0, self.yP6) 'Koordinaten aktualisieren' self.lineG1.set_data(xGl1, yGl1) 'Koordinaten von Geisterlinie2' xGl2 = (0, self.xP7) yGl2 = (0, self.yP7) 'Koordinaten aktualisieren' self.lineG2.set_data(xGl2, yGl2) 'Sichtbarkeit des Geistes ändern' #Sichtbarkeit ändern - True oder False self.pointG6.set_visible(b) self.pointG7.set_visible(b) self.lineG1.set_visible(b) self.lineG2.set_visible(b) 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw() '''Methode modellrechnung - Die Methode rechnet die kartesischen Mittelpunktkoordinaten in Polarkoordinaten um.''' def modellrechnung(self, xP6, yP6, xP7, yP7): 'Kartesische Koordinaten' 'Punkt6 und Punkt7' self.xP6 = xP6 self.yP6 = yP6 self.xP7 = xP7 self.yP7 = yP7 'Polarkoordinaten' 'Radien von Punkt6 und Punkt7' self.r6 = ((self.xP6)**2 + (self.yP6)**2)**(1/2) self.r7 = self.r6 'Winkel im Intervall [0, 2*pi]' 'Winkel von Punkt6 berechnen' self.phi6 = winkel_berechnen(self.xP6, self.yP6) 'Winkel von Punkt7 berechnen' self.phi7 = self.phi6 + pi 'Winkel theta5 (Denavit-Hartenberg-Parameter) berechnen' self.theta5 = pi - self.phi6 '''Methode punkte_faerben - Die Methode färbt oder entfärbt den bewegbaren Punkt6.''' def punkte_faerben(self, b): 'Fallunterscheidung' if b == True: #Farbe farbe = self.farbe_punkt elif b == False: #Schwarz farbe = self.farbe_allgemein 'Farbe von Punkt6 festlegen' self.point6.set_facecolor(farbe) 'Das gesamte Bild neu zeichnen' self.point.figure.canvas.draw()
def scatter_plot(self, equators=True, tagging=True, depth_cap=None, node_coloring=None): """ Plot the tree with nodes and edges, optionally equators and tagging nodes with node numbers. The tree is traversed in a breath-first-search. Note: - To distinct each generations, a color plate of ["blue", "red", "yellow", "green", "black"] is used repeatedly. - The X, Y, Z axises have been labelled. - When the number of nodes is large and the tree is bushy, it's advised disabling tagging for better user experience. :param bool equators: whether to draw the 3D equators, default True :param bool tagging: whether to tag nodes with node numbers, default True :param int depth_cap: a filter for rendering the first N generations, default tree height :param dict node_coloring: an optional map from node_id : color, to color individual nodes """ if depth_cap is None: depth_cap = self.height fig = plt.figure(figsize=(12, 10)) ax = fig.add_subplot(111, projection="3d") plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0) xs = [self.nodes[self.root.node_id].coord.x] ys = [self.nodes[self.root.node_id].coord.y] zs = [self.nodes[self.root.node_id].coord.z] plot_color_board = ["blue", "red", "yellow", "green", "black"] font0 = FontProperties() font0.set_size(8) current_generation = deque([self.root.node_id]) next_generation = True while next_generation: next_generation = deque() while current_generation: n = current_generation.popleft() if self.nodes[n].depth <= depth_cap: xs.append(self.nodes[n].coord.x) ys.append(self.nodes[n].coord.y) zs.append(self.nodes[n].coord.z) if tagging: ax.text(self.nodes[n].coord.x + 0.01, self.nodes[n].coord.y + 0.01, self.nodes[n].coord.z + 0.01, ("n{0}".format(n)), fontproperties=font0) for child in self.nodes[n].children: next_generation.append(child.node_id) if self.nodes[n].depth <= depth_cap: xe = [ self.nodes[n].coord.x, self.nodes[child.node_id].coord.x ] ye = [ self.nodes[n].coord.y, self.nodes[child.node_id].coord.y ] ze = [ self.nodes[n].coord.z, self.nodes[child.node_id].coord.z ] if node_coloring: ax.plot(xe, ye, ze, node_coloring.get(n, 'black')) else: ax.plot(xe, ye, ze, plot_color_board[self.nodes[n].depth % 5]) current_generation = next_generation ax.scatter(xs, ys, zs, c="r", marker="o") global_radius = self.nodes[self.root.node_id].radius * 1.12 if equators: for axis in ["x", "y", "z"]: circle = Circle((0, 0), global_radius * 1.1) circle.set_clip_box(ax.bbox) circle.set_edgecolor("gray") circle.set_alpha(0.3) circle.set_facecolor("none") # "none" not None ax.add_patch(circle) art3d.pathpatch_2d_to_3d(circle, z=0, zdir=axis) ax.set_xlim([-1.2 * global_radius, 1.2 * global_radius]) ax.set_ylim([-1.2 * global_radius, 1.2 * global_radius]) ax.set_zlim([-1.2 * global_radius, 1.2 * global_radius]) ax.set_xlabel("X Label") ax.set_ylabel("Y Label") ax.set_zlabel("Z Label") plt.show()
from matplotlib.patches import Rectangle import matplotlib.pyplot as pyplot matplotlib.rcParams['lines.linewidth'] = 2 pyplot.axis([0, gridWidth, 0, gridHeight]) # Setting the axis labels. pyplot.xlabel('X Space') pyplot.ylabel('Y Space') #Give the plot a title pyplot.title('Radius Search Plot Using Shapely') # Draw the collision circle/boundary cir = Circle((circleX, circleY), radius=circleRadius, fc='b', zorder=2) cir.set_alpha(0.1) x = [] y = [] col = [] clist = ['c', 'm', 'y', 'k', 'b', 'g', 'r'] b = RtreeIndex.leaves() for i in b: pyplot.gca().add_patch( Rectangle((i[2][0], i[2][1]), i[2][2] - i[2][0], i[2][3] - i[2][1], fill=False))
stateSol = odeint(EOM, X0, timeVector, args=(a, b)) # pass ################################## # x, y, z, a, b, c, dx, dy, dz, da, db, dc = orbit.T # Figure fig = plt.figure(figsize=(13, 8)) ax = fig.gca() ax.scatter(stateSol[0], stateSol[2], s=20, c='b') #stateSol[:,0] # LumpedMass payload lumpedPayload = Circle((stateSol[0, 0], stateSol[0, 0]), 13) Circle.set_color(lumpedPayload, '0.75') Circle.set_alpha(lumpedPayload, 0.1) ax.add_patch(lumpedPayload) # art3d.pathpatch_2d_to_3d(plane, z=0, zdir="z") # rectangular payload rectPayload = Rectangle((stateSol[0, 0], stateSol[0, 0]), 13, 20) Rectangle.set_color(rectPayload, '0.75') Rectangle.set_alpha(rectPayload, 0.1) ax.add_patch(rectPayload) # art3d.pathpatch_2d_to_3d(plane, z=0, zdir="z") def axAddStarts(ax): # Some stars (real stars should *NOT* move so quickly!) ax.set_axis_bgcolor('#060A49') for k in range(50):