def init_main_st(self, water_pts): (x1, y1) = random.choice(water_pts) n = self.array[x1][y1] n1_options = list(set(n.range()) - set(n.local())) n1 = np.random.choice(n1_options, replace=False) while Type.WATER in n1.type: n1 = np.random.choice(n1_options, replace=False) n2_options = list(set(n1.range()) - set(n1.local())) n2 = np.random.choice(n2_options, replace=False) points = get_line((n1.x, n1.y), (n2.x, n2.y)) while any(Type.WATER in self.array[x][y].type for (x, y) in points): n2 = np.random.choice(n2_options, replace=False) points = get_line((n1.x, n1.y), (n2.x, n2.y)) (x1, y1) = points[0] (x2, y2) = points[len(points)-1] self.set_type_road(points, Type.MAJOR_ROAD) middle_nodes = [] if len(points) > 2: middle_nodes = points[1:len(points)-1] self.roadsegments.add(RoadSegment(self.array[x1][y1], self.array[x2][y2], middle_nodes, Type.MAJOR_ROAD, self.roadsegments)) for (x, y) in points: adjacent = self.array[x][y].adjacent adjacent = [s for n in adjacent for s in n.adjacent] for pt in adjacent: if pt not in points: self.set_type_building([self.array[pt.x][pt.y]]) self.init_lots(x1, y1, x2, y2)
def complete_paths():
line = util.get_line()[0:util.get_cursor_col_num() - 1]
m = re.search("res://(((\w|-)+/)*)$", line)
if m:
project_dir = util.get_project_dir()
if not project_dir:
return
# Directories and files are grouped and sorted separately.
dirs = []
files = []
base_dir = "{}/{}".format(project_dir, m.group(1))
if not os.path.isdir(base_dir):
return
for entry in os.listdir(base_dir):
if not entry.startswith("."):
if not util.filter(entry):
continue
if os.path.isdir("{}/{}".format(base_dir, entry)):
dirs.append("{}/".format(entry))
else:
files.append(entry)
for d in sorted(dirs):
append_completion(d)
for f in sorted(files):
append_completion(f)
def get_extended_class(start_line=None):
# Figure out if we're in an inner class and return its extended type if so.
if not start_line:
start_line = util.get_cursor_line_num()
start_indent = util.get_indent(start_line)
if start_indent > 0:
for decl in iter_decls(start_line, -1, FUNC_DECLS | CLASS_DECLS):
indent = util.get_indent(decl.line)
if indent == start_indent:
continue
decl_type = type(decl)
if decl_type is FuncDecl:
start_indent = indent
elif decl_type is ClassDecl:
if decl.extends:
return decl.extends
else:
return None
if indent == 0:
break
# Search for 'extends' at the top of the file.
for lnum in range(1, util.get_line_count()):
line = util.get_line(lnum)
m = re.match("extends\s+(\w+)", line)
if m:
return m.group(1)
# Only 'tool' can appear before 'extends', so stop searching if any other
# text is encountered.
elif not re.match("tool\s+$", line):
return None
def extractGrid(veins, out_img, fuzz_cell_scale, drawLines=False):
new_x = float(out_img.shape[1]) / float(fuzz_cell_scale)
new_y = float(out_img.shape[0]) / float(fuzz_cell_scale)
grid_old_to_new = {} # MAPPING OF OLD CELLS TO NEW CELLS, ACCESS AS 2D ARRAY
new_cell_counts = {} # MAPPING OF NEW CELLS TO COUNT OF VEIN OCCURRENCES PER CELL
print 'VEINS! %d' % len(veins)
for x in range(0, out_img.shape[1]):
for y in range(0, out_img.shape[0]):
new_x_cell = math.floor(float(x) / float(fuzz_cell_scale))
new_y_cell = math.floor(float(y) / float(fuzz_cell_scale))
if drawLines:
cv2.line(out_img, (int(new_x_cell*fuzz_cell_scale),0), (int(new_x_cell*fuzz_cell_scale), out_img.shape[0]), colors[4], 1)
cv2.line(out_img, (0,int(new_y_cell*fuzz_cell_scale)), (out_img.shape[1], int(new_y_cell*fuzz_cell_scale)), colors[4], 1)
if x not in grid_old_to_new:
grid_old_to_new[x] = {}
grid_old_to_new[x][y] = (new_x_cell, new_y_cell)
new_cell_counts[(new_x_cell, new_y_cell)] = 0
for vi, vein in enumerate(veins):
used_grid_points = set()
for line in vein:
points = util.get_line(line[0][0], line[0][1], line[1][0], line[1][1])
for point in points:
new_cell = grid_old_to_new[point[0]][point[1]]
if new_cell not in used_grid_points:
new_cell_counts[new_cell] += 1
used_grid_points.add(new_cell)
vein_features['fuzzy_grid_heatmap'] = new_cell_counts
def _iter_decls_down(start_line, flags):
# Check whether the starting line is a class decl.
# If so, the indent of the next line is used as a baseline to determine
# which items are direct children of the inner class.
in_class = False
class_decl = _get_decl(start_line, CLASS_DECLS)
if class_decl:
in_class = True
class_indent = util.get_indent(start_line)
inner_indent = None
if flags & CLASS_DECLS:
yield class_decl
for lnum in range(start_line + 1, util.get_line_count()):
if not util.get_line(lnum):
continue
indent = util.get_indent(lnum)
if in_class:
if indent <= class_indent:
return
if not inner_indent:
inner_indent = indent
elif indent > inner_indent:
continue
else:
if indent > 0:
continue
decl = _get_decl(lnum, flags)
if decl:
yield decl
def _get_decl(lnum, flags):
line = util.get_line(lnum)
if flags & VAR_DECLS:
m = re.match(_VAR_PATTERN, line)
if m:
return VarDecl(lnum, m.group(1), None)
if flags & CONST_DECLS:
m = re.match(_CONST_PATTERN, line)
if m:
return ConstDecl(lnum, m.group(1), m.group(2))
if flags & FUNC_DECLS:
m = re.match(_FUNC_PATTERN, line)
if m:
static = m.group(1) != None
name = m.group(2)
args = m.group(3)
if args:
args = [a.strip() for a in args.split(",")]
return FuncDecl(lnum, static, name, args)
if flags & ENUM_DECLS:
m = re.match(_ENUM_PATTERN, line)
if m:
return EnumDecl(lnum, m.group(1))
if flags & CLASS_DECLS:
m = re.match(_CLASS_PATTERN, line)
if m:
return ClassDecl(lnum, m.group(1), m.group(2))
def get_enum_values(line_num):
lines = [util.strip_line(line_num, util.get_line(line_num))]
line_count = util.get_line_count()
while not lines[-1].endswith("}"):
line_num += 1
if line_num > line_count:
return
lines.append(util.strip_line(line_num, util.get_line(line_num)))
m = re.match(_ENUM_VALUES_PATTERN, "\n".join(lines), re.DOTALL)
if m:
values = [v.strip() for v in m.group(1).replace("\n", ",").split(",")]
def map_value(v):
m = re.match("(\w+)(?:\s*=\s*(.*))?", v)
if m:
return ConstDecl(-1, m.group(1), m.group(2))
return list(filter(lambda v: v, map(map_value, values)))
def list_all_sessions():
"""print a list of all backuped sessions (with short info)"""
if not len(tmux_dict.keys()):
#name is empty, show all list(short info)
l = util.all_backups()
if not l or len(l) == 0:
LOG.info("No backup was created yet.\nretmux -b [name] to create backup" )
sys.exit()
last = util.latest_backup().split('/')[-1]
latest_tmux = util.get_tmux_by_id(last)
#add into dict
i=1
tmux_dict[str(i)]=latest_tmux
bk_list = [ b for b in l if b != last]
for tmux_id in bk_list:
tmux = util.get_tmux_by_id(tmux_id)
i+=1
tmux_dict[str(i)]=tmux
list_fmt = '%s%2s %s'#fmt for list all, the first %s is the '*' place
print util.get_line('=')
#header
print list_fmt %(' ', 'No.',tmux_obj.Tmux.short_format%('Name','Sessions','Created on'))
print util.get_line('=')
keys = tmux_dict.keys()
keys.sort()
for idx in keys:
tmux = tmux_dict[idx]
latest_flag = '*' if idx == '1' else ' '
print list_fmt%(latest_flag, idx, tmux.short_info())
print util.get_line('-')
print '%72s'%'Latest default backup with (*)'
def render(self, t): a = self.m1.length() b = self.m2.length() x = self.m1.x + (a**2 - b**2 + self.separation**2)/(2*self.separation) inside = (-(a - b - self.separation)*(a + b - self.separation)*(a + b + self.separation)/self.separation**2) y = self.m1.y + cmath.sqrt(inside).real/2 ln1 = util.get_line(self.m1.x, self.m1.y, int(x), int(y)) ln2 = util.get_line(self.m2.x, self.m2.y, int(x), int(y)) for (lx, ly) in ln1: with t.location(int(lx), int(ly)): print "*" for (lx, ly) in ln2: with t.location(int(lx), int(ly)): print "*" with t.location(int(x), int(y)): print "X" self.m1.render(t) self.m2.render(t)
def complete_dot():
line_num = util.get_cursor_line_num()
line = util.get_line(line_num)
col_num = util.get_cursor_col_num()
token_chain = script.get_token_chain(line, line_num, col_num - 2)
if token_chain:
last_token = token_chain[-1]
last_token_type = type(last_token)
# Complete statically accessible items in classes.
if last_token_type is script.ClassToken:
# Class is defined by Godot.
if last_token.line == -1:
c = classes.get_class(last_token.name)
# Manually add an entry for 'new()' for core types.
if not c.is_built_in():
new_func = classes.GodotMethod("new", c.get_name(), [],
None)
append_completion(build_completion(new_func, c.get_name()))
_add_class_items(c, _CONSTANTS)
else:
for decl in script.iter_static_decls(last_token.line,
script.ANY_DECLS):
append_completion(build_completion(decl))
return
# Treat 'self' like we're accessing script variables, but exclude globals.
if last_token_type is script.VariableToken and last_token.name == "self":
complete_script(include_globals=False)
return
# Complete enum values.
if last_token_type is script.EnumToken:
values = script.get_enum_values(last_token.line)
if values:
for value in values:
append_completion(build_completion(value))
return
c_name = None
flags = None
if len(token_chain
) == 1 and last_token_type is script.SuperAccessorToken:
c_name = script.get_extended_class(line_num)
flags = _METHODS
elif last_token_type is script.MethodToken:
c_name = last_token.returns
elif last_token_type is script.VariableToken:
c_name = last_token.type
if c_name:
_add_class_items(classes.get_class(c_name), flags)
def set_new_road(self, x1, y1, road_type, leave_lot=False, correction=5): check1 = True #? check2 = True node = self.array[x1][y1] point, points = get_closest_point(node, self.lots, self.roads, road_type, leave_lot, correction=correction) if point is None: return (x2, y2) = point point2 = None if road_type == Type.MINOR_ROAD: point2 = get_point_to_close_gap_minor(x1, y1, self, points) elif road_type == Type.MAJOR_ROAD: point2 = get_point_to_close_gap_major(node, x1, y1, self, points) if point2 is not None: (x1, y1) = point2 points.extend(get_line((x2, y2), (x1, y1))) check1 = True self.roadnodes.append(self.array[x1][y1]) self.roadnodes.append(self.array[x2][y2]) middle_nodes = [] if len(points) > 2: middle_nodes = points[1:len(points)-1] if check1: n1 = self.array[x1][y1] for rs in self.roadsegments: if (x1, y1) in rs.nodes: rs.split(n1, self.roadsegments, self.roadnodes) break if check2: n2 = self.array[x2][y2] for rs in self.roadsegments: if (x2, y2) in rs.nodes: rs.split(n2, self.roadsegments, self.roadnodes) break self.roadsegments.add(RoadSegment(self.array[x1][y1], self.array[x2][y2], middle_nodes, road_type, self.roadsegments)) self.set_type_road(points, road_type)
def show_and_action(name=None, action=None):
"""list backups info. if name was given, show detailed info for given
backup item. otherwise show short_info for all backups as list
if there is action, will do the action after the details was displayed.
the action should be a function with single argument of tmux_obj.Tmux instance
"""
#using restore check function to validate the given name
name = tmux_id_4_show(name)
if not name:
#interactively show details
while 1:
list_all_sessions()
idx = raw_input(
"retmux> Please give backup No. (press q to exit):")
if not idx:
log.print_err("Invalid index: (empty)")
elif idx.lower() == 'q':
break
elif not tmux_dict.has_key(idx):
log.print_err("Invalid index: " + idx)
else:
tmux = tmux_dict[idx]
print util.get_line('>')
print log.hl('Details of backup:', 'bold') + '%s' % tmux.tid
print util.get_line('>')
print '\n'.join(tmux.long_info())
print util.get_line('<')
if action:
action(tmux)
else:
#till here, the name should be validated, exists
print log.hl('Details of backup:', 'bold') + '%s' % name
print util.get_line('=')
tmux = util.get_tmux_by_id(name)
print '\n'.join(tmux.long_info())
if action:
action(tmux)
def show_and_action(name=None, action=None):
"""list backups info. if name was given, show detailed info for given
backup item. otherwise show short_info for all backups as list
if there is action, will do the action after the details was displayed.
the action should be a function with single argument of tmux_obj.Tmux instance
"""
#using restore check function to validate the given name
name = tmux_id_4_show(name)
if not name:
#interactively show details
while 1:
list_all_sessions()
idx = raw_input("retmux> Please give backup No. (press q to exit):")
if not idx:
log.print_err("Invalid index: (empty)")
elif idx.lower() == 'q':
break
elif not tmux_dict.has_key(idx):
log.print_err("Invalid index: " + idx)
else:
tmux = tmux_dict[idx]
print util.get_line('>')
print log.hl('Details of backup:','bold') +'%s'% tmux.tid
print util.get_line('>')
print '\n'.join(tmux.long_info())
print util.get_line('<')
if action:
action(tmux)
else:
#till here, the name should be validated, exists
print log.hl('Details of backup:','bold') +'%s'% name
print util.get_line('=')
tmux = util.get_tmux_by_id(name)
print '\n'.join(tmux.long_info())
if action:
action(tmux)
def gdscript_complete():
util.clear_cache()
completer.clear_completions()
line = util.get_line()[0:util.get_cursor_col_num()]
syn_attr = util.get_syn_attr()
if syn_attr == "gdComment":
return
elif syn_attr == "gdString":
completer.complete_paths()
elif re.match("(\s*class\s+\w+\s+)?extends\s*", line):
completer.complete_class_names(classes.EXTENDABLE)
elif re.match("export\(\s*", line):
completer.complete_class_names(classes.EXPORTABLE)
elif re.match("\s*func", line):
completer.complete_method_signatures()
elif line and line[-1] == ".":
completer.complete_dot()
else:
completer.complete_script(include_globals=True)
completions = completer.get_completions()
vim.command("let gdscript_completions = " + str(completions))
def can_see_player(monster, game_data, visibility=10):
visible = tcod.map_is_in_fov(game_data.fov_map, monster.pos.x,
monster.pos.y)
return visible
"""
this doesn't work nicely yet for some corners, player can see monster but monster can't see player
in situations like this, M=monster, P=player, = are walls
M
= =
P
This is because the lines goes directly down first, crossing the wall and thus being blocked
"""
vec = monster.pos - game_data.player.pos
if vec.length() > visibility:
return False
points = get_line(monster.pos.tuple(), game_data.player.pos.tuple())
for p in points:
x, y = p
if game_data.map.tiles[x][y].block_sight:
return False
return True
def list_all_sessions():
"""print a list of all backuped sessions (with short info)"""
if not len(tmux_dict.keys()):
#name is empty, show all list(short info)
l = util.all_backups()
if not l or len(l) == 0:
LOG.info(
"No backup was created yet.\nretmux -b [name] to create backup"
)
sys.exit()
last = util.latest_backup().split('/')[-1]
latest_tmux = util.get_tmux_by_id(last)
#add into dict
i = 1
tmux_dict[str(i)] = latest_tmux
bk_list = [b for b in l if b != last]
for tmux_id in bk_list:
tmux = util.get_tmux_by_id(tmux_id)
i += 1
tmux_dict[str(i)] = tmux
list_fmt = '%s%2s %s' #fmt for list all, the first %s is the '*' place
print util.get_line('=')
#header
print list_fmt % (' ', 'No.', tmux_obj.Tmux.short_format %
('Name', 'Sessions', 'Created on'))
print util.get_line('=')
keys = tmux_dict.keys()
keys.sort()
for idx in keys:
tmux = tmux_dict[idx]
latest_flag = '*' if idx == '1' else ' '
print list_fmt % (latest_flag, idx, tmux.short_info())
print util.get_line('-')
print '%72s' % 'Latest default backup with (*)'
def parse_trace():
''' Parse McStas trace output from stdin and write results
to file objects csv_comps and csv_lines '''
mpl.rcParams['legend.fontsize'] = 10
fig = plt.figure(figsize=plt.figaspect(0.5)*1.5)
ax = fig.gca(projection='3d')
ax.set_xlabel("z")
ax.set_ylabel("x")
ax.set_zlabel("y")
ax.set_aspect('equal')
# ax.autoscale_view(scalex=False, scaley=False, scalez=False)
color = 0
# map from component name to (position, rotation matrix)
comps = {}
# active (position, rotation matrix)
comp = (np.array([0, 0, 0]),
np.array([1, 0, 0,
0, 1, 0,
0, 0, 1]).reshape(3,3))
# previous neutron position
prev = None
skip = False
# we are drawing a neutron
active = False
xstate=[]
ystate=[]
zstate=[]
while True:
# read line
line = get_line()
if not line:
break
# register components
if line.startswith(UC_COMP):
# grab info line
info = get_line()
assert info[:4] == 'POS:'
nums = [x.strip() for x in info[4:].split(',')]
# extract fields
name = line[len(UC_COMP):].strip(' "\n')
pos = np.array([float(x) for x in nums[:3]])
# read flat 3x3 rotation matrix
rot = np.array([float(x) for x in nums[3:3+9]]).reshape(3, 3)
comps[name] = (pos, rot)
# switch perspective
elif line.startswith(MC_COMP):
color += 1
comp = comps[line[len(MC_COMP) + 1:]]
elif line.startswith(MC_COMP_SHORT):
name = line[len(MC_COMP_SHORT) + 1:].strip('"')
comp = comps[name]
skip = True
# process multiline
elif line.startswith(MC_LINE):
points = parse_multiline(line[len(MC_LINE):].strip('()'))
start = points.pop(0)
(x, y, z) = rotate_points(points, comp)
ax.plot(z, x, y)
# process circle
elif line.startswith(MC_CIRCLE):
xyz = 'xyz'
items = line[len(MC_CIRCLE):].strip('()').split(',')
# plane
pla = [xyz.find(a) for a in items[0].strip("''")]
# center and radius
pos = [float(x) for x in items[1:4]]
rad = float(items[4])
(x,y,z) = draw_circle(pla, pos, rad, comp)
ax.plot(z, x, y)
# activate neutron when it enters
elif line.startswith(MC_ENTER):
prev = None
skip = True
active = True
color = 0
xstate=[]
ystate=[]
zstate=[]
# deactivate neutron when it leaves
elif line.startswith(MC_LEAVE):
ax.plot(zstate, xstate, ystate)
active = False
prev = None
elif line.startswith(MC_ABSORB):
pass
# register state and scatter
elif line.startswith(MC_STATE) or line.startswith(MC_SCATTER):
if not active:
continue
if skip:
skip = False
continue
xyz = [float(x) for x in line[line.find(':')+1:].split(',')[:3]]
xyz = rotate(xyz, comp)
if prev is not None:
xstate.append(xyz[0])
ystate.append(xyz[1])
zstate.append(xyz[2])
prev = xyz
xstate.append(prev[0])
ystate.append(prev[1])
zstate.append(prev[2])
# kick out legacy "junk"
elif line.startswith(MC_MAGNIFY) or line.startswith(MC_START) or line.startswith(MC_END) or line.startswith(MC_STOP):
continue
else:
print line
# A little bit of logic for controlling the aspect ratios/view
(xmin, xmax)=ax.get_xlim3d()
(ymin, ymax)=ax.get_ylim3d()
(zmin, zmax)=ax.get_zlim3d()
dx = xmax - xmin
dy = ymax - ymin
dz = zmax - zmin
dmax=max(dx,dy,dz)
# Check ranges and define axis box of max length cubed
if dmax > dx:
mean=(xmax+xmin)/2
xmin=mean-dmax/2
xmax=mean+dmax/2
if dmax > dy:
mean=(ymax+ymin)/2
ymin=mean-dmax/2
ymax=mean+dmax/2
if dmax > dz:
mean=(zmax+zmin)/2
zmin=mean-dmax/2
zmax=mean+dmax/2
# Set new axis limits
ax.set_xlim3d(xmin,xmax)
ax.set_ylim3d(ymin,ymax)
ax.set_zlim3d(zmin,zmax)
plt.show()
def parse_trace(csv_comps, csv_lines):
''' Prase McStas trace output from stdin and write results
to file objects csv_comps and csv_lines '''
color = 0
def out_point((p_x, p_y, p_z)):
''' Write a line to csv_lines '''
csv_lines.write('%s, %s, %s, %s\n' % (p_x, p_y, p_z, color))
# print headers
csv_comps.write('name, x, y, z\n')
csv_lines.write('x, y, z, c\n')
# map from component name to (position, rotation matrix)
comps = {}
# active (position, rotation matrix)
comp = (np.array([0, 0, 0]),
np.array([1, 0, 0,
0, 1, 0,
0, 0, 1]).reshape(3,3))
# previous neutron position
prev = None
skip = False
# we are drawing a neutron
active = False
while True:
# read line
line = get_line()
if not line:
break
# register components
if line.startswith(UC_COMP):
# grab info line
info = get_line()
assert info[:4] == 'POS:'
nums = [x.strip() for x in info[4:].split(',')]
# extract fields
name = line[len(UC_COMP):].strip(' "\n')
pos = np.array([float(x) for x in nums[:3]])
# read flat 3x3 rotation matrix
rot = np.array([float(x) for x in nums[3:3+9]]).reshape(3, 3)
comps[name] = (pos, rot)
csv_comps.write('%s, %s, %s, %s\n' % ((name,) + tuple(pos)))
# switch perspective
elif line.startswith(MC_COMP):
color += 1
comp = comps[line[len(MC_COMP) + 1:]]
elif line.startswith(MC_COMP_SHORT):
name = line[len(MC_COMP_SHORT) + 1:].strip('"')
comp = comps[name]
skip = True
# process multiline
elif line.startswith(MC_LINE):
points = parse_multiline(line[len(MC_LINE):].strip('()'))
start = points.pop(0)
while points:
end = points.pop(0)
for point in (start, end):
out_point(rotate(point, comp))
start = end
# process circle
elif line.startswith(MC_CIRCLE):
xyz = 'xyz'
items = line[len(MC_CIRCLE):].strip('()').split(',')
# plane
pla = [xyz.find(a) for a in items[0].strip("''")]
# center and radius
pos = [float(x) for x in items[1:4]]
rad = float(items[4])
draw_circle(pla, pos, rad, comp, out_point)
# activate neutron when it enters
elif line.startswith(MC_ENTER):
prev = None
skip = True
active = True
color += 1
# deactivate neutron when it leaves
elif line.startswith(MC_LEAVE):
active = False
elif line.startswith(MC_ABSORB):
pass
# register state and scatter
elif line.startswith(MC_STATE) or line.startswith(MC_SCATTER):
if not active:
continue
if skip:
skip = False
continue
xyz = [float(x) for x in line[line.find(':')+1:].split(',')[:3]]
xyz = rotate(xyz, comp)
if prev is not None:
out_point(prev)
out_point(xyz)
prev = xyz
def build_donor(app_ctx):
click.echo('in build_donor...')
schema = app_ctx['input_schemas']['donor']
fname = os.path.join(schema['data_path'], schema['main_file_name'])
annotations = {}
util.read_annotations(annotations, 'pcawg_donorlist', schema['annotations_path']+'pc_annotation-pcawg_final_list.tsv')
util.read_annotations(annotations, 'blacklist', schema['annotations_path']+'blacklist/pc_annotation-donor_blacklist.tsv')
util.read_annotations(annotations, 'graylist', schema['annotations_path']+'graylist/pc_annotation-donor_graylist.tsv')
util.read_annotations(annotations, 'uuid_to_barcode', schema['annotations_path']+'pc_annotation-tcga_uuid2barcode.tsv')
util.read_annotations(annotations, 'icgc_donor_id', schema['annotations_path']+'icgc_bioentity_ids/pc_annotation-icgc_donor_ids.csv')
util.read_annotations(annotations, 'icgc_specimen_id', schema['annotations_path']+'icgc_bioentity_ids/pc_annotation-icgc_specimen_ids.csv')
util.read_annotations(annotations, 'icgc_sample_id', schema['annotations_path']+'icgc_bioentity_ids/pc_annotation-icgc_sample_ids.csv')
util.read_annotations(annotations, 'specimen_type_to_cv', schema['annotations_path']+'pc_annotation-tcga_specimen_type2icgc_cv.tsv')
util.read_annotations(annotations, 'specimen_uuid_to_type', schema['annotations_path']+'pc_annotation-tcga_specimen_uuid2type.tsv')
donor = {}
specimen = {}
# build the donor and specimen objects
with open(fname, 'r') as f:
reader = csv.DictReader(f, delimiter='\t', quoting=csv.QUOTE_NONE)
for r in reader:
donor_unique_id = r.get('disease.x')+'-US::'+r.get('participant_id')
if not donor.get(donor_unique_id):
#new donor: initial the donor
donor[donor_unique_id] = create_obj(donor_unique_id, schema, r, annotations, 'donor')
if not specimen.get('mirna'):
specimen['mirna'] = {}
specimen_id = r.get('sample_id')
if not specimen['mirna'].get(specimen_id):
specimen['mirna'][specimen_id] = create_obj(donor_unique_id, schema, r, annotations, 'mirna')
aliquot = create_obj(donor_unique_id, schema, r, annotations, 'aliquot')
specimen['mirna'][specimen_id]['aliquots'].append(copy.deepcopy(aliquot))
specimen['mirna'][specimen_id]['donor_unique_id'] = donor_unique_id
# build the specimen object from help file
fname = os.path.join(schema['data_path'], schema['help_file_name'])
with open(fname, 'r') as f:
reader = csv.DictReader(f, delimiter='\t', quoting=csv.QUOTE_NONE)
for r in reader:
donor_unique_id = r.get('donor_unique_id')
specimen_id = r.get('submitter_specimen_id')
dtype = 'rna_seq' if r.get('library_strategy') == 'RNA-Seq' else 'wgs'
if not specimen.get(dtype):
specimen[dtype] = {}
if not specimen[dtype].get(specimen_id):
specimen[dtype][specimen_id] = create_obj(donor_unique_id, schema, r, annotations, dtype)
specimen[dtype][specimen_id]['donor_unique_id'] = donor_unique_id
if os.path.exists(app_ctx['output_dir']):
shutil.rmtree(app_ctx['output_dir'])
os.makedirs(app_ctx['output_dir'])
# add specimen to donor
crossref_specimen_ids = {}
crossref_specimen_ids['rna_seq'] = specimen['rna_seq'].keys()
crossref_specimen_ids['wgs'] = specimen['wgs'].keys()
json2tsv_fields_map = schema['json2tsv_fields_map']
sample_sheet_fields_donor = schema['target_tsv_file']['mirna_sample_sheet']['donor']
sample_sheet_fields_specimen = schema['target_tsv_file']['mirna_sample_sheet']['specimen']
sample_sheet_fields_sample = schema['target_tsv_file']['mirna_sample_sheet']['sample']
with open(os.path.join(app_ctx['output_dir'], 'mirna_sample_sheet.tsv'), 'a') as f:
f.write('\t'.join(sample_sheet_fields_donor+sample_sheet_fields_specimen+sample_sheet_fields_sample) + '\n')
for dtype in ['mirna', 'rna_seq', 'wgs']:
#loop on the specimen to add it to donor
for k, v in specimen[dtype].iteritems():
donor_unique_id = v.get('donor_unique_id')
if not donor.get(donor_unique_id):
continue
if (not donor[donor_unique_id]['pcawg_donor']) and (not 'normal' in v.get('dcc_specimen_type').lower()):
continue
sample_sheet = OrderedDict()
sample_sheet.update(util.get_dict_value(sample_sheet_fields_donor, donor[donor_unique_id], json2tsv_fields_map))
# check whether wgs and rna_seq has the mirna specimen
if dtype == 'mirna':
v['has_matched_wgs_specimen'] = True if k in crossref_specimen_ids.get('wgs') else False
v['has_matched_rna_seq_specimen'] = True if k in crossref_specimen_ids.get('rna_seq') else False
sample_sheet.update(util.get_dict_value(sample_sheet_fields_specimen, v, json2tsv_fields_map))
for aliquot in v.get('aliquots'):
sample_sheet.update(util.get_dict_value(sample_sheet_fields_sample, aliquot, json2tsv_fields_map))
line = util.get_line(sample_sheet)
# # generate mirna_sample_sheet
with open(os.path.join(app_ctx['output_dir'], 'mirna_sample_sheet.tsv'), 'a') as f:
f.write('\t'.join(line) + '\n')
v.pop('donor_unique_id')
if 'normal' in v.get('dcc_specimen_type').lower():
donor[donor_unique_id]['normal'][dtype] = v
else:
donor[donor_unique_id]['tumor'][dtype].append(v)
# get release_tsv fields
release_fields = schema['target_tsv_file']['mirna_release_tsv']
with open(os.path.join(app_ctx['output_dir'], 'mirna_release.tsv'), 'a') as f:
f.write('\t'.join(release_fields) + '\n')
# remove the donors only have tumor mirna specimen
for k, v in donor.iteritems():
if (not v['pcawg_donor']) and (not v.get('normal').get('mirna')):
continue
for dtype in ['mirna', 'rna_seq', 'wgs']:
v['tumor_'+dtype+'_specimen_count'] = len(v['tumor'][dtype]) if v['tumor'].get(dtype) else 0
# generate the jsonl dump
with open(os.path.join(app_ctx['output_dir'], 'mirna_release.jsonl'), 'a') as f:
f.write(json.dumps(v) + '\n')
# # generate mirna_release_tsv list
tsv_obj = util.get_dict_value(release_fields, v, json2tsv_fields_map)
line = util.get_line(tsv_obj)
with open(os.path.join(app_ctx['output_dir'], 'mirna_release.tsv'), 'a') as f:
f.write('\t'.join(line) + '\n')
click.echo('complete in build_donor...')
def get_closest_point(node,
lots,
road_segments,
road_type,
leave_lot,
correction=5):
# check if road can leave lot
(x, y) = (node.x, node.y)
nodes = road_segments
# if not leave_lot:
# if node.lot is None:
# return None
# nodes = set(road_segments) & node.lot.get_nodes()
# filter out bridges
nodes = [n for n in nodes if Type.BRIDGE not in n.type]
if len(nodes) == 0:
print("leave_lot = {} no road segments".format(leave_lot))
return None, None
dists = [math.hypot(n.x - x, n.y - y) for n in nodes]
node2 = nodes[dists.index(min(dists))]
(x2, y2) = (node2.x, node2.y)
# if node.lot is not None and road_type is not Type.MINOR_ROAD:
# if abs(x - x2) < correction:
# x = x2
# node = node.landscape.array[x][y]
# elif abs(y - y2) < correction:
# y = y2
# node = node.landscape.array[x][y]
if node.lot is None:
if road_type is not Type.MINOR_ROAD and abs(x2 - x) > 10 and abs(
y2 - y) > 10:
if node2.lot is not None:
(cx2, cy2) = node2.lot.center
(x, y) = (x + x - cx2, y + y - cy2)
if x >= node.landscape.x:
x = node.landscape.x - 1
if x < 0:
x = 0
if y >= node.landscape.y:
y = node.landscape.y - 1
if y < 0:
y = 0
# else:
# (x2, y2) = (node2.x, node2.y)
if abs(x2 - x) > 10 and abs(
y2 - y) > 10: # and road_type is Type.MAJOR_ROAD:
if not node.landscape.add_lot([(x2, y2), (x, y)]):
print("leave_lot = {} add lot failed".format(leave_lot))
return None, None
# else:
# print("leave_lot = {} proposed lot is too small{} or road is not MAJOR_ROAD{}".format(leave_lot, abs(x2 - x) > 10 and abs(y2 - y) > 10, road_type is Type.MAJOR_ROAD))
# return None
else:
return None, None
points = get_line((x, y), (node2.x, node2.y))
if len(points) <= 2:
return None, None
if not leave_lot:
for (i, j) in points:
if Type.WATER in node.landscape.array[i][j].type:
return None, None
return (node2.x, node2.y), points
def parse_trace(csv_comps, csv_lines):
''' Prase McStas trace output from stdin and write results
to file objects csv_comps and csv_lines '''
color = 0
def out_point((p_x, p_y, p_z)):
''' Write a line to csv_lines '''
csv_lines.write('%s, %s, %s, %s\n' % (p_x, p_y, p_z, color))
# print headers
csv_comps.write('name, x, y, z\n')
csv_lines.write('x, y, z, c\n')
# map from component name to (position, rotation matrix)
comps = {}
# active (position, rotation matrix)
comp = (np.array([0, 0, 0]), np.array([1, 0, 0, 0, 1, 0, 0, 0,
1]).reshape(3, 3))
# previous neutron position
prev = None
skip = False
# we are drawing a neutron
active = False
while True:
# read line
line = get_line()
if not line:
break
# register components
if line.startswith(UC_COMP):
# grab info line
info = get_line()
assert info[:4] == 'POS:'
nums = [x.strip() for x in info[4:].split(',')]
# extract fields
name = line[len(UC_COMP):].strip(' "\n')
pos = np.array([float(x) for x in nums[:3]])
# read flat 3x3 rotation matrix
rot = np.array([float(x) for x in nums[3:3 + 9]]).reshape(3, 3)
comps[name] = (pos, rot)
csv_comps.write('%s, %s, %s, %s\n' % ((name, ) + tuple(pos)))
# switch perspective
elif line.startswith(MC_COMP):
color += 1
comp = comps[line[len(MC_COMP) + 1:]]
elif line.startswith(MC_COMP_SHORT):
name = line[len(MC_COMP_SHORT) + 1:].strip('"')
comp = comps[name]
skip = True
# process multiline
elif line.startswith(MC_LINE):
points = parse_multiline(line[len(MC_LINE):].strip('()'))
start = points.pop(0)
while points:
end = points.pop(0)
for point in (start, end):
out_point(rotate(point, comp))
start = end
# process circle
elif line.startswith(MC_CIRCLE):
xyz = 'xyz'
items = line[len(MC_CIRCLE):].strip('()').split(',')
# plane
pla = [xyz.find(a) for a in items[0].strip("''")]
# center and radius
pos = [float(x) for x in items[1:4]]
rad = float(items[4])
draw_circle(pla, pos, rad, comp, out_point)
# activate neutron when it enters
elif line.startswith(MC_ENTER):
prev = None
skip = True
active = True
color += 1
# deactivate neutron when it leaves
elif line.startswith(MC_LEAVE):
active = False
elif line.startswith(MC_ABSORB):
pass
# register state and scatter
elif line.startswith(MC_STATE) or line.startswith(MC_SCATTER):
if not active:
continue
if skip:
skip = False
continue
xyz = [float(x) for x in line[line.find(':') + 1:].split(',')[:3]]
xyz = rotate(xyz, comp)
if prev is not None:
out_point(prev)
out_point(xyz)
prev = xyz
def parse_trace(world, fp=sys.stdin, inspectComp=None):
""" Prase McStas trace output from stdin and write result to output """
color = 0
# def out_point((p_x, p_y, p_z)):
# ''' Write a line to csv_lines '''
# csv_lines.write('%s, %s, %s, %s\n' % (p_x, p_y, p_z, color))
# print headers
# csv_comps.write('name, x, y, z\n')
# csv_lines.write('x, y, z, c\n')
# map from component name to (position, rotation matrix)
comps = {}
# active (position, rotation matrix)
comp = (np.array([0, 0, 0]), np.array([1, 0, 0, 0, 1, 0, 0, 0, 1]).reshape(3, 3))
compName = ""
# we are following a neutron
active = False
# we need to draw the neutron (it passed the "check-point"/inspect component)
inspect = False
# list of observed neutron positions
neutron = []
# skip next neutron position
skip = False
# total count of drawed neutrons
neutrons_drawed = 0
while True:
# read line
line = get_line(fp)
if line is None:
break
# register components
if line.startswith(UC_COMP):
# grab info line
info = get_line(fp)
assert info[:4] == "POS:"
nums = [x.strip() for x in info[4:].split(",")]
# extract fields
name = line[len(UC_COMP) :].strip(' "\n')
pos = np.array([float(x) for x in nums[:3]])
# read flat 3x3 rotation matrix
rot = np.array([float(x) for x in nums[3 : 3 + 9]]).reshape(3, 3)
comps[name] = (pos, rot)
# csv_comps.write('%s, %s, %s, %s\n' % ((name,) + tuple(pos)))
# switch perspective
elif line.startswith(MC_COMP):
color += 1
name = line[len(MC_COMP) + 1 :].strip()
compName = name
comp = comps[name]
elif line.startswith(MC_COMP_SHORT):
name = line[len(MC_COMP_SHORT) + 1 :].strip('"')
compName = name
comp = comps[name]
skip = True
# process multiline
elif line.startswith(MC_LINE):
points = parse_multiline(line[len(MC_LINE) :].strip("()"))
world.drawLine((rotate(p, comp) for p in points), color=getColor(color))
# process circle
elif line.startswith(MC_CIRCLE):
xyz = "xyz"
items = line[len(MC_CIRCLE) :].strip("()").split(",")
# plane
pla = [xyz.find(a) for a in items[0].strip("''")]
# center and radius
pos = [float(x) for x in items[1:4]]
rad = float(items[4])
points = draw_circle(pla, pos, rad, comp)
world.drawLine(points, color=getColor(color))
# activate neutron when it enters
elif line.startswith(MC_ENTER):
neutron = []
skip = True
active = True
inspect = False
color += 1
# deactivate neutron when it leaves
elif line.startswith(MC_LEAVE) or line.startswith(MC_ABSORB):
active = False
if inspectComp is None or inspect:
world.drawLine(neutron, color="1 0 0")
neutrons_drawed += 1
# register state and scatter
elif line.startswith(MC_STATE) or line.startswith(MC_SCATTER):
if not active:
continue
if skip:
skip = False
continue
if inspectComp and inspectComp == compName:
# We will draw this neutron!
inspect = True
# keep track of points the neutron passes through
xyz = [float(x) for x in line[line.find(":") + 1 :].split(",")[:3]]
xyz = rotate(xyz, comp)
neutron.append(xyz)
print "Neutrons drawed:", neutrons_drawed, (inspectComp and "(reaching %s)" % inspectComp or "(all)")
return world
def parse_trace(world, fp=sys.stdin, inspectComp=None):
''' Prase McStas trace output from stdin and write result to output '''
color = 0
# def out_point((p_x, p_y, p_z)):
# ''' Write a line to csv_lines '''
# csv_lines.write('%s, %s, %s, %s\n' % (p_x, p_y, p_z, color))
# print headers
# csv_comps.write('name, x, y, z\n')
# csv_lines.write('x, y, z, c\n')
# map from component name to (position, rotation matrix)
comps = {}
# active (position, rotation matrix)
comp = (np.array([0, 0, 0]), np.array([1, 0, 0, 0, 1, 0, 0, 0,
1]).reshape(3, 3))
compName = ""
# we are following a neutron
active = False
# we need to draw the neutron (it passed the "check-point"/inspect component)
inspect = False
# list of observed neutron positions
neutron = []
# skip next neutron position
skip = False
# total count of drawed neutrons
neutrons_drawed = 0
while True:
# read line
line = get_line(fp)
if line is None:
break
# register components
if line.startswith(UC_COMP):
# grab info line
info = get_line(fp)
assert info[:4] == 'POS:'
nums = [x.strip() for x in info[4:].split(',')]
# extract fields
name = line[len(UC_COMP):].strip(' "\n')
pos = np.array([float(x) for x in nums[:3]])
# read flat 3x3 rotation matrix
rot = np.array([float(x) for x in nums[3:3 + 9]]).reshape(3, 3)
comps[name] = (pos, rot)
# csv_comps.write('%s, %s, %s, %s\n' % ((name,) + tuple(pos)))
# switch perspective
elif line.startswith(MC_COMP):
color += 1
name = line[len(MC_COMP) + 1:].strip()
compName = name
comp = comps[name]
elif line.startswith(MC_COMP_SHORT):
name = line[len(MC_COMP_SHORT) + 1:].strip('"')
compName = name
comp = comps[name]
skip = True
# process multiline
elif line.startswith(MC_LINE):
points = parse_multiline(line[len(MC_LINE):].strip('()'))
world.drawLine((rotate(p, comp) for p in points),
color=getColor(color))
# process circle
elif line.startswith(MC_CIRCLE):
xyz = 'xyz'
items = line[len(MC_CIRCLE):].strip('()').split(',')
# plane
pla = [xyz.find(a) for a in items[0].strip("''")]
# center and radius
pos = [float(x) for x in items[1:4]]
rad = float(items[4])
points = draw_circle(pla, pos, rad, comp)
world.drawLine(points, color=getColor(color))
# activate neutron when it enters
elif line.startswith(MC_ENTER):
neutron = []
skip = True
active = True
inspect = False
color += 1
# deactivate neutron when it leaves
elif line.startswith(MC_LEAVE) or line.startswith(MC_ABSORB):
active = False
if inspectComp is None or inspect:
world.drawLine(neutron, color="1 0 0")
neutrons_drawed += 1
# register state and scatter
elif line.startswith(MC_STATE) or line.startswith(MC_SCATTER):
if not active:
continue
if skip:
skip = False
continue
if inspectComp and inspectComp == compName:
# We will draw this neutron!
inspect = True
# keep track of points the neutron passes through
xyz = [float(x) for x in line[line.find(':') + 1:].split(',')[:3]]
xyz = rotate(xyz, comp)
neutron.append(xyz)
print('Neutrons drawed:', neutrons_drawed,
(inspectComp and '(reaching %s)' % inspectComp or '(all)'))
return world
def parse_trace():
''' Parse McStas trace output from stdin and write results
to file objects csv_comps and csv_lines '''
mpl.rcParams['legend.fontsize'] = 10
fig = plt.figure(figsize=plt.figaspect(0.5) * 1.5)
ax = fig.gca(projection='3d')
ax.set_xlabel("z")
ax.set_ylabel("x")
ax.set_zlabel("y")
ax.set_aspect('equal')
# ax.autoscale_view(scalex=False, scaley=False, scalez=False)
color = 0
# map from component name to (position, rotation matrix)
comps = {}
# active (position, rotation matrix)
comp = (np.array([0, 0, 0]), np.array([1, 0, 0, 0, 1, 0, 0, 0,
1]).reshape(3, 3))
# previous neutron position
prev = None
skip = False
# we are drawing a neutron
active = False
xstate = []
ystate = []
zstate = []
while True:
# read line
line = get_line()
if not line:
break
# register components
if line.startswith(UC_COMP):
# grab info line
info = get_line()
assert info[:4] == 'POS:'
nums = [x.strip() for x in info[4:].split(',')]
# extract fields
name = line[len(UC_COMP):].strip(' "\n')
pos = np.array([float(x) for x in nums[:3]])
# read flat 3x3 rotation matrix
rot = np.array([float(x) for x in nums[3:3 + 9]]).reshape(3, 3)
comps[name] = (pos, rot)
# switch perspective
elif line.startswith(MC_COMP):
color += 1
comp = comps[line[len(MC_COMP) + 1:]]
elif line.startswith(MC_COMP_SHORT):
name = line[len(MC_COMP_SHORT) + 1:].strip('"')
comp = comps[name]
skip = True
# process multiline
elif line.startswith(MC_LINE):
points = parse_multiline(line[len(MC_LINE):].strip('()'))
start = points.pop(0)
(x, y, z) = rotate_points(points, comp)
ax.plot(z, x, y)
# process circle
elif line.startswith(MC_CIRCLE):
xyz = 'xyz'
items = line[len(MC_CIRCLE):].strip('()').split(',')
# plane
pla = [xyz.find(a) for a in items[0].strip("''")]
# center and radius
pos = [float(x) for x in items[1:4]]
rad = float(items[4])
(x, y, z) = draw_circle(pla, pos, rad, comp)
ax.plot(z, x, y)
# activate neutron when it enters
elif line.startswith(MC_ENTER):
prev = None
skip = True
active = True
color = 0
xstate = []
ystate = []
zstate = []
# deactivate neutron when it leaves
elif line.startswith(MC_LEAVE):
ax.plot(zstate, xstate, ystate)
active = False
prev = None
elif line.startswith(MC_ABSORB):
pass
# register state and scatter
elif line.startswith(MC_STATE) or line.startswith(MC_SCATTER):
if not active:
continue
if skip:
skip = False
continue
xyz = [float(x) for x in line[line.find(':') + 1:].split(',')[:3]]
xyz = rotate(xyz, comp)
if prev is not None:
xstate.append(xyz[0])
ystate.append(xyz[1])
zstate.append(xyz[2])
prev = xyz
xstate.append(prev[0])
ystate.append(prev[1])
zstate.append(prev[2])
# kick out legacy "junk"
elif line.startswith(MC_MAGNIFY) or line.startswith(
MC_START) or line.startswith(MC_END) or line.startswith(
MC_STOP):
continue
else:
print(line)
# A little bit of logic for controlling the aspect ratios/view
(xmin, xmax) = ax.get_xlim3d()
(ymin, ymax) = ax.get_ylim3d()
(zmin, zmax) = ax.get_zlim3d()
dx = xmax - xmin
dy = ymax - ymin
dz = zmax - zmin
dmax = max(dx, dy, dz)
# Check ranges and define axis box of max length cubed
if dmax > dx:
mean = (xmax + xmin) / 2
xmin = mean - dmax / 2
xmax = mean + dmax / 2
if dmax > dy:
mean = (ymax + ymin) / 2
ymin = mean - dmax / 2
ymax = mean + dmax / 2
if dmax > dz:
mean = (zmax + zmin) / 2
zmin = mean - dmax / 2
zmax = mean + dmax / 2
# Set new axis limits
ax.set_xlim3d(xmin, xmax)
ax.set_ylim3d(ymin, ymax)
ax.set_zlim3d(zmin, zmax)
plt.show()
def echodoc_search():
util.clear_cache()
text = vim.eval("a:text")
text_len = len(text)
if text_len == 0:
return
m = re.match("\w+", text)
if not m:
return
method_name = m.group(0)
chain_start = util.get_cursor_col_num() - text_len - 1
line_num = util.get_cursor_line_num()
line = util.get_line(line_num)[:chain_start]
line = "{}{}()".format(line, method_name)
method_args = None
tokens = script.get_token_chain(line, line_num, len(line))
if tokens and type(tokens[-1]) is script.MethodToken:
method_args = tokens[-1].args
else:
return
hl_identifier = vim.eval("g:echodoc#highlight_identifier")
hl_arguments = vim.eval("g:echodoc#highlight_arguments")
arg_hl_index = 0
paren_count = 0
for char in text[len(m.group(0)) + 1:]:
if char == "(":
paren_count += 1
elif char == ")":
paren_count -= 1
elif char == "," and paren_count <= 0:
arg_hl_index += 1
echodoc = [{
"text": method_name,
"highlight": hl_identifier
}, {
"text": "("
}]
arg_count = len(method_args)
for (i, arg) in enumerate(method_args):
if arg.type:
echodoc.append({
"text": "{} ".format(arg.type),
"highlight": "gdClass"
})
d = {"text": arg.name}
if arg_hl_index == i:
d["highlight"] = hl_arguments
echodoc.append(d)
if arg_count - 1 > i:
echodoc.append({"text": ", "})
if tokens[-1].qualifiers and "vararg" in tokens[-1].qualifiers:
if arg_count > 0:
echodoc.append({"text": ", "})
d = {"text": "..."}
if arg_hl_index >= arg_count:
d["highlight"] = hl_arguments
echodoc.append(d)
echodoc.append({"text": ")"})
vim.command("let echodoc_search_result = {}".format(str(echodoc)))
