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 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 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)
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
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):
