def test_wedge_movement():
param_dict = {
'center': ((0, 0), (1, 1), 'set_center'),
'r': (5, 8, 'set_radius'),
'width': (2, 3, 'set_width'),
'theta1': (0, 30, 'set_theta1'),
'theta2': (45, 50, 'set_theta2')
}
init_args = {k: v[0] for k, v in param_dict.items()}
w = mpatches.Wedge(**init_args)
for attr, (old_v, new_v, func) in param_dict.items():
assert getattr(w, attr) == old_v
getattr(w, func)(new_v)
assert getattr(w, attr) == new_v
def test_wedge_movement():
param_dict = {
'center': ((0, 0), (1, 1), 'set_center'),
'r': (5, 8, 'set_radius'),
'width': (2, 3, 'set_width'),
'theta1': (0, 30, 'set_theta1'),
'theta2': (45, 50, 'set_theta2')
}
init_args = dict((k, v[0]) for (k, v) in six.iteritems(param_dict))
w = mpatches.Wedge(**init_args)
for attr, (old_v, new_v, func) in six.iteritems(param_dict):
assert_equal(getattr(w, attr), old_v)
getattr(w, func)(new_v)
assert_equal(getattr(w, attr), new_v)
def plot2(d, outfile):
fig, ax = plt.subplots()
pieValues = d.values()
wedges, texts = ax.pie(
pieValues,
# colors=colors,
# explode=explode,
# autopct='%1.1f%%',
# startangle=90,
# wedgeprops={'linewidth': 0.5, 'edgecolor': 'black'}
# pctdistance=0.85
)
ax.set_aspect('equal')
ax.axis('off')
groups = [[0], [1, 2], [3, 4]]
radfraction = 0.1
patches = []
for i in groups:
# print((wedges[i[-1]].theta2 + wedges[i[0]].theta1)/2)
ang = np.deg2rad((wedges[i[-1]].theta2 + wedges[i[0]].theta1)/2,)
print(ang)
for j in i:
we = wedges[j]
print(we)
print(ang)
center = (radfraction*we.r*np.cos(ang), radfraction*we.r*np.sin(ang))
patches.append(mpatches.Wedge(center, we.r, we.theta1, we.theta2))
# # print(patches)
# colors = ['#E26882', '#EDC363', '#5EC3E5', '#47E0B7', '#A273CE']
colors = np.linspace(0, 1, len(patches))
collection = PatchCollection(patches, cmap=plt.cm.hsv)
collection.set_array(np.array(colors))
collection = PatchCollection(patches)
ax.add_collection(collection)
ax.autoscale(True)
fig.tight_layout()
# plt.savefig(outfile, dpi=300, format=None)
plt.savefig(outfile)
def update_el(self, el, state):
''' el = TSCS.EL
state = STATL.TELDRIVE '''
self.logger.debug('updating el=%s state=%s' % (str(el), state))
val, color = self.__get_val_state(el, state)
try:
Artist.remove(self.el)
el_kwargs = dict(alpha=0.5, fc=color, ec=color, lw=8)
self.el = mpatches.Wedge((1, 0), 0.99, 180 - val, 180, **el_kwargs)
self.axes.add_patch(self.el)
self.draw()
except Exception as e:
self.logger.error('error: updating. %s' % str(e))
pass
def add_self_loop(self, ax, prob=None, direction='up'):
"""
Draws a self loop
"""
if direction == 'up':
start = -30
angle = 180
ring_x = self.x
ring_y = self.y + self.radius
prob_y = self.y + 1.3*self.radius
x_cent = ring_x - self.radius + (self.ring_width/2)
y_cent = ring_y - 0.15
else:
start = -210
angle = 0
ring_x = self.x
ring_y = self.y - self.radius
prob_y = self.y - 1.4*self.radius
x_cent = ring_x + self.radius - (self.ring_width/2)
y_cent = ring_y + 0.15
# Add the ring
ring = mpatches.Wedge(
(ring_x, ring_y),
self.radius,
start,
angle,
width = self.ring_width
)
# Add the triangle (arrow)
offset = 0.2
left = [x_cent - offset, ring_y]
right = [x_cent + offset, ring_y]
bottom = [(left[0]+right[0])/2., y_cent]
arrow = plt.Polygon([left, right, bottom, left])
p = PatchCollection(
[ring, arrow],
edgecolor = self.ring_edgecolor,
facecolor = self.ring_facecolor
)
ax.add_collection(p)
# Probability to add?
if prob:
ax.annotate(str(prob), xy=(self.x, prob_y), color='#000000', **self.text_args)
def create_mpl_patch(self):
"""Create a matplotlib patch for the region.
Returns
-------
patch : matplotlib patch
"""
patch = mpatches.Wedge([self.xc, self.zc],
self.radius_out,
0,
360,
self.radius_out - self.radius_in,
edgecolor='red',
facecolor="None")
return patch
def plot_bpg_connection(ref_placements,cycle,total_length,prev_seg_index_is_adj,bpg_dict,seg_end_pos_d):
connect_width = bar_width/2.
for ind,refObj in ref_placements.iteritems():
next_ind = (ind+1) % len(ref_placements)
next_refObj = ref_placements[next_ind]
if not prev_seg_index_is_adj[next_ind]: #or next_ind == 0 to try and close
bpg_adjacency = vu.pair_is_edge(refObj.id, next_refObj.id,refObj.direction, next_refObj.direction,
bpg_dict, seg_end_pos_d)
if not bpg_adjacency:
continue
start_angle, end_angle = start_end_angle(next_refObj.abs_start_pos,refObj.abs_end_pos,total_length)
#makes the reference genome wedges
patches.append(mpatches.Wedge((0,0), outer_bar - bar_width/4, end_angle, start_angle, width=connect_width))
f_color_v.append('grey')
e_color_v.append('grey')
lw_v.append(0.2)
def __init__(self, position, velocity=None, acceleration=0, animated=True):
super().__init__(position, velocity, acceleration, animated)
self.r = 15
self.phi = 50
self.sensor = patch.Wedge((self.pos[0], self.pos[1]),
self.r,
self.gch() - self.phi / 2,
self.gch() + self.phi / 2,
edgecolor='k',
facecolor=None,
fill=False)
# self.sensor= patch.Circle((self.pos[0], self.pos[1]), self.r,edgecolor='r', facecolor=None, fill=False)
ax.add_patch(self.sensor)
self.target_point, = ax.plot(0, 0, 'bo')
self.goal = np.array([35, 35])
ax.plot(*self.goal, 'go', markersize=15)
self.trail, = ax.plot(self.pos, 'ro', markersize=5)
def tas_simulate(self, data):
se = cc.SampleEnviGeometry()
TasSimulate.tas_simulate(self, data)
# add sample enviroment
for x in se.dead_angle:
if data['s1s2_limit'] == 0:
color = 'red'
else:
color = 'black'
se_dead = mpatches.Wedge(self.sample_center,
se.radius,
180 + data.m2 - x[1] - data.s1,
180 + data.m2 - x[0] - data.s1,
ec='none',
alpha=0.7,
color=color)
self.ax.add_patch(se_dead)
def animate_sector(ax, currentVessel):
current = 0
for i in range(10):
next = current + config.sectors[i]
patch = patches.Wedge(
(currentVessel.shipstate.position.x,
currentVessel.shipstate.position.y),
config.radius['ra'],
helpers.nav_to_theta(currentVessel.shipstate.heading +
current),
helpers.nav_to_theta(currentVessel.shipstate.heading + next),
ls='solid',
linewidth=1,
fill=False)
collissionSectors.append(patch)
ax.add_patch(patch)
current = next
def affichagePointsCles(im, listeAvecOrientation):
print('...Affichage des résultats')
fig, axd = plt.subplots(1)
axd.imshow(im, cmap='gray')
for liste in listeAvecOrientation:
[o, s, x, y, sigma, deltaO, theta] = liste
circ = patches.Wedge((int(y), int(x)),
sigma,
0,
360,
width=1,
color='red')
axd.add_patch(circ)
axd.add_line(
mlines.Line2D([int(y), int(y + sigma * math.sin(theta))],
[int(x), int(x + sigma * math.cos(theta))]))
plt.title('Affichage des lieux des points-clés')
plt.show()
def stepUi(cur_h, cur_depth, arc, lines):
global all_lines
a = 2. * pi * cur_h.toFloat()
b = a + 2. * pi / (2**(cur_depth))
arc.append(
ringx.add_patch(
mpatches.Wedge([
0.,
0,
],
1.,
a * 180 / pi,
b * 180 / pi,
fill=True,
color="blue",
alpha=0.5)))
lines.extend(ringx.plot([0, cos(a)], [0, sin(a)], 'k-', lw=1.2))
all_lines.extend(lines)
def plot_gene_track(currStart, genes, segment, total_length_with_spacing, strand, exons = True):
delta = control_delta if 'control' in segment.info else 0
for gene in genes:
if gene.info['Name'].upper().startswith('RP11-') or gene.info['Name'].startswith('RP4-') or gene.info['Name'].startswith('RNU6') or gene.info['Name'].startswith('SNOR') or gene.info['Name'].startswith('U6') or gene.info['Name'].startswith('AC099') or gene.info['Name'].startswith('RP5') or gene.info['Name'].startswith('U4') or gene.info['Name'].find('RNA') != -1:
continue
#e_posns is a list of tuples of exon (start,end)
#do exons
tstart,tend = (gene.start,gene.end)
#tstart,tend = (ensembl_map[gene.info['data'][-4]].start,ensembl_map[gene.info['data'][-4]].end)
seg_len = segment.end - segment.start
if strand == "+":
normStart = currStart - max(0,tstart-segment.start)
normEnd = currStart - min(segment.end-segment.start,tend-segment.start)
else:
normEnd = currStart - min(segment.end-segment.start,segment.end-tstart)
normStart = currStart - max(0,segment.end - tend)
# if tstart < pTup[1]:
# truncStart = True
# if tend > pTup[2]:
# truncEnd = True
gstart_angle = normStart/total_length_with_spacing*360
gend_angle = normEnd/total_length_with_spacing*360
text_angle = (gstart_angle + gend_angle)/2.0
if gend_angle < 0 and gstart_angle > 0:
gend_angle+=360
patches.append(mpatches.Wedge((0,0), outer_bar+delta, gend_angle, gstart_angle, width=bar_width/2.0))
color = 'r' if gene.info['Name'].upper() in oncogene_map else 'teal'
f_color_v.append(color)
e_color_v.append(color)
lw_v.append(0)
x,y = pol2cart(outer_bar+(bar_width/2.0),(text_angle/360*2*np.pi))
x_t,y_t = pol2cart(outer_bar + bar_width + gene_delta + delta,(text_angle/360*2*np.pi))
#ax.plot([x,x_t],[y,y_t],color='grey',linewidth=0.4)
if text_angle < -90 and text_angle > -360:
text_angle+=180
ax.text(x_t,y_t,gene.info['Name'],color=color,rotation=text_angle,
ha='right',fontsize=font_size,rotation_mode='anchor')
else:
ax.text(x_t,y_t,gene.info['Name'],color=color,rotation=text_angle,
ha='left',fontsize=font_size,rotation_mode='anchor')
def analysis_new_mission_commonparameters_tagged_100_200(city):
lines = commonparameters(city)
db = pymysql.connect(host=HOST,
user=USER,
password=PASSWD,
db=DB,
charset='utf8')
cursor = db.cursor()
for l in range(0, len(lines)):
cgi = lines[l][4]
district = lines[l][3]
shapes = gaodemapscene(district, city, 120000)
Path = mpath.Path
for s in range(0, len(shapes)):
shape = shapes[s][-1]
shape_array = np.array([
float(i)
for i in shape.replace('|', ',').replace(';', ',').split(',')
]).reshape(-1, 2)
angle = float(lines[l][18])
point = (float(lines[l][15]), float(lines[l][14]))
Path(shape_array)
try:
a = mpatches.Wedge(point,
0.0018,
angle - 65,
angle + 65,
width=0.0009)._path.vertices
a = Polygon(a).buffer(0)
b = Polygon(shape_array)
c = a.intersection(b)
polygon = Polygon(c)
f = polygon.area / b.area
except NotImplementedError as e:
f = 0
if f > 0.5:
query_commonparameters_tagged = """UPDATE {} set residential_flag='3' where cgi='{}'""".format(
TABLE_NAME_ANALYSIS_Commonparameters, cgi)
cursor.execute(query_commonparameters_tagged)
break
print('%.2f%%' % (l / len(lines) * 100))
cursor.close()
db.commit()
db.close()
def plot_ref_cmaps(start_point,seg_cmap_vector):
start_angle = start_point/total_length_with_spacing*360
end_angle = (start_point - seg_cmap_vector[-1])/total_length_with_spacing*360
if end_angle < 0 and start_angle >0:
end_angle+=360
patches.append(mpatches.Wedge((0,0), mid_bar+bar_width, end_angle, start_angle, width=bar_width))
f_color_v.append('darkorange')
e_color_v.append('k')
lw_v.append(0)
lab_locs = []
print seg_cmap_vector
for i in seg_cmap_vector[:-1]:
label_angle = (start_point - i)/total_length_with_spacing*2*np.pi
x,y = pol2cart(mid_bar,label_angle)
x_t,y_t = pol2cart(mid_bar+bar_width,label_angle)
ax.plot([x,x_t],[y,y_t],color='k',alpha=0.9,linewidth=0.2)
lab_locs.append(start_point - i)
return lab_locs
def drawBot(self, row, col, angleRotation, cellSize, axes):
"""Metodo dibuja a BB8 en una posicion.
Argumentos:
+ row (int): Fila que nos indica en que fila esta el bot
+ col (int): Fila que nos indica en que columna esta el bot
+ angleRotation (int): No se usa
+ cellSize (float): Tamaño de la celda a dibujar el robot
+ axes (matplotlib axes): Ejes donde se dibuja el bot
"""
x = (col + 0.5) * cellSize
y = (row + 0.5) * cellSize
#Dibujamos a BB8
head1 = mpatches.Wedge((0, 0.25), cellSize / 5, 0, 180, color="orange")
head2 = mpatches.Circle((0, 0.4), radius=cellSize / 16, color="black")
body1 = mpatches.Circle((0, -0.25),
radius=cellSize / 4,
color="orange")
body2 = mpatches.Circle((0, -0.25), radius=cellSize / 6, color="white")
#Movemos el poligono a la posicion indicada
t2 = mpl.transforms.Affine2D().translate(x, y)
#Unimos todas las transformaciones
tra = t2 + axes.transData
head1.set_transform(tra)
body1.set_transform(tra)
body2.set_transform(tra)
head2.set_transform(tra)
patches = []
patches.append(head1)
patches.append(body1)
patches.append(body2)
patches.append(head2)
self.drawing = patches
for parts in patches:
axes.add_patch(parts)
def draw_screen(self):
title = " Avg. Reward: %d Reward: %d Total Game: %d" % (
self.total_reward / self.total_game, self.current_reward,
self.total_game)
self.axis.clear()
self.axis.set_title(title, fontsize=12)
road = patches.Rectangle((self.road_left - 1, 0),
self.road_width + 1,
self.screen_height,
linewidth=0,
facecolor="#333333")
if self._is_gameover():
car_color = "#FF0000"
else:
car_color = "#00FF00"
car = patches.Wedge((self.car["col"] - 0.5, self.car["row"] - 0.5),
0.5,
20,
340,
linewidth=0,
facecolor=car_color)
block1 = patches.Circle(
(self.block[0]["col"] - 0.5, self.block[0]["row"]),
0.5,
linewidth=0,
facecolor="#0099FF")
block2 = patches.Circle(
(self.block[1]["col"] - 0.5, self.block[1]["row"]),
0.5,
linewidth=0,
facecolor="#EB70AA")
self.axis.add_patch(road)
self.axis.add_patch(car)
self.axis.add_patch(block1)
self.axis.add_patch(block2)
self.fig.canvas.draw()
plt.pause(0.0001)
def updateIcon(self, now):
self.timePassedAngle = int(
(now - self.start + 0.5) / (self.end - self.start) * 360)
#self.fig = plt.figure(figsize=(1, 1), dpi=100)
#self.fig.delaxes(self.ax)
#self.ax = self.fig.add_subplot(111)
if self.timePassedAngle < 360:
#self.w1 = pat.Wedge(center = (0.5, 0.5), r = 0.5, theta1 = 0, theta2 = 360, color = 'black', width=0.03 )
self.w2 = pat.Wedge(
center=(0.5, 0.5),
r=0.45,
theta1=90,
theta2=450 - self.timePassedAngle,
color=actTmColor if self.timerActive else deactTmColor)
#self.ax.add_patch(self.w1)
self.ax.add_patch(self.w2)
plt.axis('off')
plt.savefig(self.img_path, transparent=True, dpi=100)
self.icon = self.img_path
self.ax.clear()
def plot_flow_cyliner_2(img_epoch, m, n, epoch, Xmean):
import cmocean
x2 = np.arange(0, 384, 1)
y2 = np.arange(0, 199, 1)
mX, mY = np.meshgrid(x2, y2)
img_epoch += Xmean.reshape(m, n)
minmax = np.max(np.abs(img_epoch)) * 0.65
plt.figure(facecolor="white", edgecolor='k', figsize=(7.9, 4.7))
im = plt.imshow(img_epoch.T,
cmap=cmocean.cm.balance,
interpolation='none',
vmin=-minmax,
vmax=minmax)
plt.contourf(mX,
mY,
img_epoch.T,
80,
cmap=cmocean.cm.balance,
alpha=1,
vmin=-minmax,
vmax=minmax)
wedge = mpatches.Wedge((0, 99),
33,
270,
90,
ec="#636363",
color='#636363',
lw=5)
im.axes.add_patch(p=wedge)
#plt.title('Epoch number ' + str(epoch), fontsize = 16 )
plt.axis('off')
plt.title('Reconstructed flow filed using the shallow decoder')
plt.tight_layout()
#plt.show()
plt.savefig('results/reconstruction_via_shallow_decoder.png', dpi=300)
plt.close()
def load_and_plot_map(self, mmap):
# setup a plot axis
self.ax.set_aspect('equal')
self.ax.set_xlim(-3, 3)
self.ax.set_ylim(0, 5)
for i in range(mmap["num_markers"]):
# load marker pose
map_entry = "marker{0}".format(i)
x = mmap[map_entry]["x"]
y = mmap[map_entry]["y"]
th = mmap[map_entry]["theta"]
if mmap[map_entry]["units"][0] == "inch":
x *= inch_to_meter
y *= inch_to_meter
if mmap[map_entry]["units"][1] == "deg":
th *= np.pi / 180.0
# calculate marker boarders for plotting
x_border = np.array([
x + 0.5 * self.marker_size * np.cos(th),
x - 0.5 * self.marker_size * np.cos(th)
])
y_border = np.array([
y + 0.5 * self.marker_size * np.sin(th),
y - 0.5 * self.marker_size * np.sin(th)
])
# plotting and keep the handle
h = self.ax.plot(x_border, y_border, 'r-', lw=2)
self.marker_handles[mmap[map_entry]["id"]] = h
# draw camera at (0, 0)
cam_wedge = mpatches.Wedge((0, 3.0),
.2,
75,
105,
facecolor="blue",
alpha=0.75)
self.cam_handle = self.ax.add_patch(cam_wedge)
def get_points(self):
if self._invalid:
points = self._viewLim.get_points().copy()
# Scale angular limits to work with Wedge.
points[:, 0] *= 180 / np.pi
if points[0, 0] > points[1, 0]:
points[:, 0] = points[::-1, 0]
# Scale radial limits based on origin radius.
points[:, 1] -= self._originLim.y0
# Scale radial limits to match axes limits.
rscale = 0.5 / points[1, 1]
points[:, 1] *= rscale
width = min(points[1, 1] - points[0, 1], 0.5)
# Generate bounding box for wedge.
wedge = mpatches.Wedge(self._center,
points[1, 1],
points[0, 0],
points[1, 0],
width=width)
self.update_from_path(wedge.get_path())
# Ensure equal aspect ratio.
w, h = self._points[1] - self._points[0]
if h < w:
deltah = (w - h) / 2.0
deltaw = 0.0
elif w < h:
deltah = 0.0
deltaw = (h - w) / 2.0
else:
deltah = 0.0
deltaw = 0.0
self._points += np.array([[-deltaw, -deltah], [deltaw, deltah]])
self._invalid = 0
return self._points
def _render_on_subplot(self, subplot):
"""
TESTS::
sage: D = disk((2,-1), 2, (0, pi), color='black', thickness=3, fill=False); D
"""
import matplotlib.patches as patches
options = self.options()
deg1 = self.rad1*(180./pi) #convert radians to degrees
deg2 = self.rad2*(180./pi)
z = int(options.pop('zorder', 0))
p = patches.Wedge((float(self.x), float(self.y)), float(self.r), float(deg1),
float(deg2), zorder=z)
p.set_linewidth(float(options['thickness']))
p.set_fill(options['fill'])
p.set_alpha(options['alpha'])
c = to_mpl_color(options['rgbcolor'])
p.set_edgecolor(c)
p.set_facecolor(c)
p.set_label(options['legend_label'])
subplot.add_patch(p)
def plot_2D_vehicle(self, ax, vehicle):
'''plot vehicle
'''
lidar = mpatches.Wedge((vehicle.location[0], vehicle.location[1]),
vehicle.lidar_length,
vehicle.lidar_theta[0],
vehicle.lidar_theta[1],
width=None,
fc='g',
alpha=0.3)
loc = mpatches.Rectangle((vehicle.location[0], vehicle.location[1]),
1,
1,
fc='k')
ax.add_patch(lidar)
ax.add_patch(loc)
return ax
def _draw_nucleotide_keys(keys_required: Optional[List[str]],
keys_optional: Optional[List[str]],
center: Sequence[float],
nucleotide_body_patch: patches.Circle,
subplot: plt_axes.Subplot,
color, radius=10.0, width=5.0,
theta_min=0, theta_max=180):
# pylint: disable=too-many-arguments
# not possible to have less arguments without more complexity
# pylint: disable=too-many-locals
# is not possible to split the method without more complexity
keys_required = keys_required or []
keys_optional = keys_optional or []
keys_all = keys_required + keys_optional
if not keys_all:
return None
number_of_keys = len(keys_all)
theta_delta = (theta_max - theta_min) / number_of_keys
thetas = np.arange(theta_min, theta_max, theta_delta)
key_patches = {}
for each_key, each_start_theta in zip(keys_all, thetas):
hatch = "x" if each_key in keys_optional else None
theta1 = each_start_theta
theta2 = theta1 + theta_delta
key_patch = patches.Wedge(
center, radius + width, theta1, theta2, width=width,
facecolor=color, hatch=hatch, edgecolor="white")
key_patches[each_key] = key_patch
text_object = _draw_key_text(
each_key, center, theta1, theta2, radius, width, subplot)
key_patch.add_callback(partial(
_nucleotide_key_text_callback,
text_object=text_object,
nucleotide_body_patch=nucleotide_body_patch))
subplot.add_patch(key_patch)
return key_patches
def step(cur_h, cur_depth):
global done, all_nodes, all_lines
done += 1
a = 2. * pi * cur_h.toFloat()
b = a + 2. * pi / (2**(cur_depth))
print("step", cur_h, cur_depth)
arc = ringx.add_patch(
mpatches.Wedge([
0.,
0,
],
1.,
a * 180 / pi,
b * 180 / pi,
fill=True,
color="blue",
alpha=0.5))
lines = ringx.plot([0, cos(a)], [0, sin(a)], 'k-', lw=1.2)
all_lines.extend(lines)
r.get(
cur_h, gcb, lambda d, nodes: loop.call_soon_threadsafe(
nextstep, cur_h, cur_depth, d, nodes, arc, lines))
def __init__(self, xy, r, theta1, theta2, fc, ec, width, lw, mplprops,
figure):
self.xy = xy
self.r = r
self.theta1 = theta1
self.theta2 = theta2
self.mplprops = mplprops
self.figure = figure
self.width = width
self.maple = "12"
wedge = patches.Wedge(xy,
r,
theta1,
theta2,
width,
fc=fc,
ec=ec,
lw=lw,
**self.mplprops)
self.matplotlib_obj = wedge
self.patch = self.figure.ax.add_patch(self.matplotlib_obj)
def test_patch_str():
"""
Check that patches have nice and working `str` representation.
Note that the logic is that `__str__` is defined such that:
str(eval(str(p))) == str(p)
"""
p = mpatches.Circle(xy=(1, 2), radius=3)
assert str(p) == 'Circle(xy=(1, 2), radius=3)'
p = mpatches.Ellipse(xy=(1, 2), width=3, height=4, angle=5)
assert str(p) == 'Ellipse(xy=(1, 2), width=3, height=4, angle=5)'
p = mpatches.Rectangle(xy=(1, 2), width=3, height=4, angle=5)
assert str(p) == 'Rectangle(xy=(1, 2), width=3, height=4, angle=5)'
p = mpatches.Wedge(center=(1, 2), r=3, theta1=4, theta2=5, width=6)
assert str(p) == 'Wedge(center=(1, 2), r=3, theta1=4, theta2=5, width=6)'
p = mpatches.Arc(xy=(1, 2), width=3, height=4, angle=5, theta1=6, theta2=7)
expected = 'Arc(xy=(1, 2), width=3, height=4, angle=5, theta1=6, theta2=7)'
assert str(p) == expected
def AddAgent(self,name,radius,color,data,show_circle=False,circle_rad = 10):
#agt = plt.Circle((0.0, 0.0), radius=radius, fc=color)
agt = self.GetTriangle(radius,(0.0,0,0),(1.0,0.0),color)
self.ax.add_patch(agt)
self.agents.append(agt)
self.agentNames.append(name)
self.data[name] = data
self.minlen = len(data['positionNED'])
line, = plt.plot(0,0)
self.paths[name] = line
self.agentsRadius[name] = radius
if show_circle:
circlePatch = plt.Circle((0, 0), radius=circle_rad, fc='y',alpha=0.5)
self.circle[name] = circlePatch
self.ax.add_patch(circlePatch)
# Draw bands
sectors = []
for i in range(10):
ep = patches.Wedge((0,0),circle_rad,theta1=0,theta2=0,fill=True,alpha=0.6)
sectors.append(ep)
self.ax.add_patch(ep)
self.bands[name] = sectors
def get_angle_intensity_glyphs(xy, angles, magnitudes, **kwargs):
"""Returns a list of pie glyphs at coordinates xy representing values
Parameters
----------
xy: array
An (N, 2) array of the xy coordinates of the glyphs.
angles: float radians
An (N, ) array of the angles of the glyphs.
magnitudes: float
An (N, ...) array of the magnitudes of the glyphs.
"""
assert len(xy) == len(magnitudes), \
"Each value needs exactly one coodrinate."
assert len(xy) == len(angles), \
"Each value needs exactly one coodrinate."
# Normalize angles to [0, 1] range
angles = np.mod(angles * 0.5 / np.pi, 1.0)
# Assign angle to hue, and magnitude value in hsv colorspace
hsv = np.ones([len(magnitudes), 3])
hsv[:, 0] = angles
hsv[:, 2] = magnitudes
# Determine properties of each glyph
wedge_arc = 120 # degrees
wedge_start = angles * 360
wedge_color = hsv_to_rgb(hsv)
# Create pie wedges
wedges = list()
for i in range(len(xy)):
wedges.append(
patches.Wedge(
xy[i],
0.5, # radius
wedge_start[i],
wedge_start[i] + wedge_arc,
color=wedge_color[i],
linewidth=0, # otherwise wedges overlap
**kwargs))
return wedges
def PlotWindow(ax, d1, d2, count):
angle_fraction = 360 / count
# angle = angle_fraction * 0.5
# x = np.cos(angle*np.pi/180)*d1
# y = np.sin(angle*np.pi/180)*d1
# x2 = np.cos(angle*np.pi/180)*d2
# y2 = np.sin(angle*np.pi/180)*d2
# ax.plot((x,x2),(y,y2), "black")
# angle = angle_fraction * -0.5
# x = np.cos(angle*np.pi/180)*d1
# y = np.sin(angle*np.pi/180)*d1
# x2 = np.cos(angle*np.pi/180)*d2
# y2 = np.sin(angle*np.pi/180)*d2
# ax.plot((x,x2),(y,y2), "black")
wedge1 = mpatches.Wedge((0, 0),
d2,
angle_fraction * -0.5,
angle_fraction * 0.5,
width=d2 - d1,
ec="black",
fc="none")
ax.add_patch(wedge1)
