def main():
args = extraction_parser().parse_args()
# Get output directory
if args.output_directory is None:
outdir = os.get_cwd()
elif not os.path.isdir(args.output_directory):
raise ValueError("Output directory invalid")
else:
outdir = args.output_directory
# Start log
log_name = "injection_finder_{}".format(
os.path.split(args.registration_folder)[-1])
fancylog.start_logging(outdir, package, filename=log_name, verbose=True)
# Start extraction
Extractor(
args.img_filepath,
args.registration_folder,
logging,
overwrite=args.overwrite,
gaussian_kernel=args.gaussian_kernel,
percentile_threshold=args.percentile_threshold,
threshold_type=args.threshold_type,
obj_path=args.obj_path,
overwrite_registration=args.overwrite_registration,
)
def __init__(self, file: str, fix_seed: bool = False):
super(preprocess, self).__init__()
cwd = os.get_cwd()
self.df = pd.read_excel(os.path.join(cwd, "data", file))
self.coords = self.standardize(self.df)
self.vertices = self.generate_graph(self.coords)
ind_list = self.df.iloc[:,
6:8].drop_duplicates(keep='last').index.values
df_drop = self.df.iloc[ind_list, :].copy()
df_drop.reset_index(inplace=True)
df_drop.drop(['Unnamed: 0'], axis=1, inplace=True)
if fix_seed:
random.seed(27)
self.features = self.preset_features(df_drop)
self.targets = self.preset_targets(df_drop)
self.ids = self.preset_ids(df_drop)
self.JSON_FILE = [
MakeDictionary_GR(all_vertice, i) for i in range(len(id_array))
]
self.JSON_SHUFFLE = sorted(JSON_FILE, key=lambda k: random.random())
self.JSON_TRAIN = [JSON_SHUFFLE[i] for i in range(0, 450)]
self.JSON_VAL = [JSON_SHUFFLE[i] for i in range(450, 500)]
self.JSON_TEST = [
JSON_SHUFFLE[i] for i in range(500, len(JSON_SHUFFLE))
]
return self.JSON_TRAIN, self.JSON_VAL, self.JSON_TEST
def mddata(self, inf='md.in', outf='md.out'):
if self.md_init is None:
try:
return md.Md(inf, outf)
except FileNotFoundError:
print("No MD data found in {}".format(os.get_cwd()))
return self.md_init
def POST(self, type):
file = web.input(avatar={}, background={})
file_dir = os.get_cwd(
) + "/static/uploads/" + session_data['user']['username']
if not os.path.exists(file_dir):
os.makedir(file_dir)
if "avatar" or "background" in file:
filepath = file[type].filename.replace('\\', '/')
filename = filepath.split('/')[-1]
f = open(file_dir + "/" + filename, 'wb')
f.write(file[type].file.read())
f.close()
update = {}
update['type'] = type
update['img'] = '/static/uploads' + session_data["user"][
"username"] + "/" + filename
update['username'] = session_data['user']['username']
account_model = LoginModel.LoginModel()
update_avatar = account_model.update_image(update)
raise web.seeother('/settings')
def make_at(path, dir_name):
original_path = os.get_cwd()
try:
os.chdir(path)
os.mkdir(dir_name)
except OSError as e:
print(e, file=sys.stderr)
raise
finally:
os.chdir(original_path)
def __init__(self, cwd=None, env=None):
"""
Parameters:
- cwd (opt, str): the Miniconda installation path.
Defaults to os.get_cwd()
- env (opt): a YML env file. If None provided, can't install
environment.
"""
self.log = logger.InstallLogger(__name__).gen_logger()
cwd = cwd or os.get_cwd()
self.set_install_folder(cwd)
self.set_miniconda_base_web_link(system.base_miniconda_web_link)
self.set_miniconda_web_file(
"Miniconda3-latest-{}-{}.{}".format(
system.platform,
system.bits,
system.miniconda_file_extension
)
)
self.set_miniconda_download_link(
urlparse.urljoin(
self.get_miniconda_base_web_link(),
self.get_miniconda_web_file()
)
)
self.set_miniconda_install_file(
os.path.join(
self.get_install_folder(),
self.get_miniconda_web_file()
)
)
self.set_miniconda_install_folder(
os.path.join(
self.get_install_folder(),
system.default_miniconda_folder
)
)
self.set_env_file(env)
return
def level(cwd=None):
if cwd is None:
cwd = os.get_cwd()
"""
Return the level corresponding to the folder `cwd`.
"""
pp = cwd.split(os.sep)[-1]
ll = ''
if pp.isdigit():
ll = 'day'
else:
numstr = [str(i) for i in range(10)]
ll = pp.strip(''.join(numstr))
return ll
def level(cwd=None):
if cwd is None:
cwd = os.get_cwd()
"""
Return the level corresponding to the folder `cwd`.
"""
leaf = cwd.split(os.sep)[-1]
ll = ''
if leaf.isdigit():
ll = 'day'
else:
for pattern in level_patterns_s[::-1]:
pp = re.compile(pattern)
m = pp.match(leaf)
if m is not None:
ll = m.groups()[0]
break
return ll
os.makedirs(output_folder)
# For each common covariate, find average betas and pvalues and save to file
for covar in common_covars:
avg_beta = average_results(covar, root_folder, site_list, BETA)
output_path = os.path.join(output_folder,
get_img_fname(BETA, covar))
avg_beta.to_filename(output_path)
log.info(
'Saved average beta weights for `{covar}` to {path}'.format(
covar=covar, path=output_path))
avg_pval = average_results(covar, root_folder, site_list, PVAL)
output_path = os.path.join(output_folder,
get_img_fname(PVAL, covar))
avg_pval.to_filename(output_path)
log.info('Saved average p-values for `{covar}` to {path}'.format(
covar=covar, path=output_path))
else:
log.error('No sites found')
if __name__ == '__main__':
if len(sys.argv) > 1:
folder = sys.argv[1]
else:
folder = os.get_cwd()
log.info('Root folder: ' + folder)
main(folder)
# This is the Crawler App
import sys
import os
DEBUG = os.environ.get('DEBUG', False)
#print sys.path
#print os.get_cwd()
if DEBUG:
print sys.path
print os.get_cwd()
def crawler():
pass
import sys, os
cwd = os.get_cwd()
addedpath=cwd+"/periodic_kdtree/"
sys.path.append(addedpath)
print(sys.path)
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('ggplot')
%matplotlib inline
import matplotlib as mpl
mpl.rcParams['image.cmap'] = 'autumn'
import periodic_kdtree
from periodic_kdtree import PeriodicCKDTree
import scipy.spatial
import time
from mpl_toolkits.mplot3d import Axes3D
import pickle
import gzip
import networkx as netx
def read_input_parameters(param_filename='Parameters.in'):
input_parameters = np.genfromtxt(param_filename,delimiter='=',dtype=str)
input_parameters[:,0]
input_parameters[:,1]
# input_parameter_names, input_parameter_values = np.split( input_parameters, [1], axis=1)
input_parameter_names = input_parameters[:,0]
input_parameter_values = input_parameters[:,1]
parameters = dict({})
import os
import sys
input = sys.argv[0]
cwd = os.get_cwd(input)
for _, f, _ in os.walk():
print(f)
os.remove('ic/ic1800x1800.txt')
# txt=load_buffer('ic/ic1800x1800.npz')[0]#,allow_pickle=True)
return txt
def get_txt_lst(txt_id1, width, height, worker_dir, **kwargs):
txt_in = download_txt(txt_id1, worker_dir, **kwargs)
array_lst = chunk_array(txt_in, width, height, typeout='float64')
return array_lst
def get_txt(txt_id1, txt_id2, width, height, worker_dir, **kwargs):
array_lst = get_txt_lst(txt_id1, width, height, worker_dir, **kwargs)
# N=len(array_lst)
try:
txt = array_lst[txt_id2]
except IndexError as e:
import random
print(f'IndexError for {(width,txt_id1,txt_id2)}')
print(e)
txt_id2 = random.randint(0, len(array_lst) - 1)
print(f'Choosing txt_id2={txt_id2}...')
txt = array_lst[txt_id2] #-1]
return txt
if __name__ == '__main__':
os.get_cwd()
for input_fn in sys.argv[1:]:
download_txt(txt_id, worker_dir)
def img_wscore_wrapper(scans,
mask=None,
outdir=None,
outnm='TFMd',
save_style='3d'):
''' Will transform images by using mixture modeling to determine a "normal"
distribution, and then normalizing ALL values to values along the "normal"
distribution. This procedure is done voxelwise, and voxels that do not have
a binomial distribution are simply z-scored.
NOTE: Input scans should be in the same space (i.e. a standard space) and
should be smoothed for best results.
NOTE: Providing an image mask (see arguments below) will speed up the
procedure quite a bit.
Parameters
----------
scans : list
A list of (str) paths to input images.
mask: str, optional
If a path to a mask image is passed, all images will be masked using
the mask image. Note that the mask image must be a binary image in the
same space as images in "scans". Passing a mask image will greatly speed
up computation. Passing None will perform transformation across all
voxels.
outdir: str, optional
Where to save the images to after transformation. If None is passed,
images will output to current working directory
outnm: str, optional, default 'TFMd'
String to append to the front of all images created post-transformation.
save_style: str, optional, default '3d'
String describing in what format to save files.
Must be one of::
'3d': Save each new scan individually.
'4d': Save all new scans into a single 4D image.
Note that in the '3d' case, image filenames will contain integers
reflecting the input order in scans. For example, the image pointed to
by the third path in scans will be labeled as "2".
'''
if save_style not in ['3d', '4d']:
raise IOError("save style must be set to '3d' or '4d'")
if not outdir:
print(
'WARNING: No output directory passed. Saving images to currend working directory'
)
outdir = os.get_cwd()
print('loading images')
# if input_style=='nilearn':
i4d, aff = load_images_nil(scans)
# elif input_style=='nib':
# i4d,aff = load_images_nib(scans,verbose)
masked = False
if mask:
if type(mask) == str:
if os.path.isfile(mask):
print('masking')
i2d, mskr = mask_nil(i4d, aff, mask)
masked = True
else:
raise IOError('could not find any image at path: %s' % mask)
else:
print('setting to 2D')
i2d, old_shape = to_2d(i4d)
print('beginning transformation')
transformed = img_wscore(i2d)
print('reverting back to image format')
if masked:
tfm_4d = mskr.inverse_transform(transformed).get_data()
else:
tfm_4d = back_to_4d(transformed, old_shape)
if save_style == '4d':
tfm_img = nib.Nifti1Image(tfm_4d, aff)
flnm = os.path.join(outdir, outnm)
tfm_img.to_filename(flnm)
elif save_style == '3d':
for i in range(tfm_4d.shape[-1]):
tfm_img = nib.Nifti1Image(tfm_4d[:, :, :, i], aff)
flnm = os.path.join(outdir, outnm + '_%s' % i)
tfm_img.to_filename(flnm)
type=str,
nargs="+",
required=True,
help="Text file listing all HDF5 Dataset to use for training.")
argument_parser.add_argument('-d',
'--validation_data',
type=str,
nargs="+",
required=True,
help="Text file listing all HDF5 Dataset to use for validation.")
argument_parser.add_argument(
'--hdf_dir',
type=str,
default=os.get_cwd(),
help="Path to the folder to store the hdf dataset.")
if __main__ == "__name__":
# set the rng to defined settings
# from keras_impl import seedsettings
#
from trainkeras import TrainKeras as TrainLib
trainer = TrainLib()
args = argument_parser.parse_args()
return None
#### Args Parser ####
# add parser options
parser = OptionParser()
parser.add_option('-m', '--volume', dest='volume', help='mount point')
parser.add_option('-p', '--path', dest='isopath', help='path of iso')
(opts, args) = parser.parse_args()
if opts.isopath != None:
repo = opts.isopath
else:
repo = os.get_cwd()
if opts.volume != None:
# replace / from the end
root = re.sub(r'/+$', '', opts.isopath)
else:
pass
# ? reinstall directions
# print(opts.volume, opts.isopath)
#### Get Path ####
part = ""
# Add a intervention handle afterwards
for line in open('/proc/mounts').readlines():
mnt = line.split()
def cwd(self):
print('os.get_cwd():', os.get_cwd())
def sequence(parameters,
subNumber,
subID=None,
simulate=False,
nMax=None,
win=None,
path=None,
oxi=None):
"""Run the entire task sequence.
Parameters
----------
parameters : dictionnary
Dictionnary containing task parameters.
subNumber : int
Subject number.
subID : str or None, default is `None`
Subject ID.
simulate : boolean, default is `False`
Simulate data based on random sampling.
nMax : int or None, default is `None`
If provided, limit the number or trials to nMax. To do used for testing
purpose.
win : psychopy Window. Default is None
The window in which displaying.
path : str or None, default is `None`
Folder containing the task files and Result folder.
oxi : Instance of Oximeter
Where recording devise.
Notes
-----
If recording, will store data at the end o0f each block. The final dataframe
is saved as `result_df`.
"""
if path is None:
path = os.get_cwd()
if oxi:
oxi.setup()
result_df = pd.DataFrame([])
# Generate blocks orders
arousing = np.array([1, 3, 1, 3, 1, 3])
nonarounsing = np.array([2, 4, 2, 4, 2, 4])
np.random.shuffle(arousing)
np.random.shuffle(nonarounsing)
if (subNumber % 2) == 0:
blockOrder = []
for i in range(6):
blockOrder.append(arousing[i])
blockOrder.append(nonarounsing[i])
elif (subNumber % 2) != 0:
blockOrder = []
for i in range(6):
blockOrder.append(nonarounsing[i])
blockOrder.append(arousing[i])
else:
raise ValueError('Invalid subject number.')
# Generate learning times
timeList = [[30, 60, 90], [30, 90, 60], [60, 30, 90], [60, 90, 30],
[90, 30, 60], [90, 60, 30]]
nTime = timeList[(subNumber % 6)]
# Generate Learning/Distractors lists
if (subNumber % 2) == 0:
learningList, distractorList = [1, 3, 5], [2, 4, 6]
else:
learningList, distractorList = [2, 4, 6], [1, 3, 5]
# Read dataframes
df_1 = pd.read_csv(path + '/Material/1_WordList_ValHighAroHigh.csv',
dtype={'List': 'int'})
df_2 = pd.read_csv(path + '/Material/2_WordList_ValHighAroLow.csv',
dtype={'List': 'int'})
df_3 = pd.read_csv(path + '/Material/3_WordList_ValLowAroHigh.csv',
dtype={'List': 'int'})
df_4 = pd.read_csv(path + '/Material/4_WordList_ValLowAroLow.csv',
dtype={'List': 'int'})
words_df = {'1': df_1, '2': df_2, '3': df_3, '4': df_4}
# Run the sequence
end = False
for nBlock, block in enumerate(blockOrder):
if end:
break
# Show instructions, break and wait for space press
if nBlock == 0:
instructions(parameters=parameters, show_intructions=True, win=win)
else:
instructions(parameters=parameters, win=win)
if oxi:
oxi.setup()
oxi.read(nSeconds=1)
df = words_df[str(block)]
# Security check
if (len(df[df.List == learningList[0]]) != len(
df[df.List == distractorList[0]])):
raise ValueError("""Inconsistent list size Learning/Distractor
per condition""")
# Find the index for learning and distractor
# Check if both values are present in the List column
if ((learningList[0] in df.List.unique()) &
(distractorList[0] in df.List.unique())):
indexLearning, indexDistractor = learningList[0], distractorList[0]
timeLearning = nTime[0]
# Check if both values are present in the List column
elif ((learningList[1] in df.List.unique()) &
(distractorList[1] in df.List.unique())):
indexLearning, indexDistractor = learningList[1], distractorList[1]
timeLearning = nTime[1]
# Check if both values are present in the List column
elif ((learningList[2] in df.List.unique()) &
(distractorList[2] in df.List.unique())):
indexLearning, indexDistractor = learningList[2], distractorList[2]
timeLearning = nTime[2]
else:
raise ValueError('Invalid lists')
# Use the index to select the learning and distractors words
learning_df = df[df.List == indexLearning].reset_index()
distractor_df = df[df.List == indexDistractor].reset_index()
# Drop the row corresponding to learning list AND distractor list
df = df[df.List != indexLearning]
df = df[df.List != indexDistractor]
words_df[str(block)] = df
# Run the learning phase
if not simulate:
oxi = learning(listStudied=list(learning_df.Word),
timeLearning=timeLearning,
win=win,
oxi=oxi)
# Run trials
positionLength = int(len(learning_df) / 2)
wordPosition = np.hstack(
(np.zeros(positionLength), np.ones(positionLength)))
np.random.shuffle(wordPosition)
for i in range(len(learning_df)):
word1 = learning_df.iloc[i].Word
word2 = distractor_df.iloc[i].Word
if simulate:
mean = np.random.normal(2, 0.5, 1)[0]
std = np.random.normal(2, 0.2, 1)[0]
rt = np.random.normal(mean, std, 1)[0]
accuracy = np.random.choice([True, False])
keyPressed = np.random.choice(['left', 'right'])
confidence = np.random.choice([1, 2, 3, 4, 5, 6])
confidence_rt = np.random.normal(mean, std, 1)[0]
else:
expectedCorrect, accuracy, keyPressed, rt, confidence, \
confidence_rt, oxi, markerStart, word1, word2 = \
trial(parameters, word1, word2,
shift=wordPosition[i], win=win, oxi=oxi)
# Update the result Dataframe
result_df = result_df.append(
{
'RT': rt,
'Expected': expectedCorrect,
'Accuracy': accuracy,
'LearningTime': timeLearning,
'nBlock': nBlock,
'Confidence': confidence,
'Confidence_RT': confidence_rt,
'TrialNumber': i,
'MarkerStart': markerStart,
'Valence': parameters['Conditions'][str(block)][0],
'Arousal': parameters['Conditions'][str(block)][1],
'KeyPressed': keyPressed,
'LeftWord': word1,
'RightWord': word2
},
ignore_index=True)
# If nMax elapsed end the task here
if nMax:
if i >= nMax:
end = True
break
# Save the result_df after each block
result_df.to_csv(path + '/Results/Subject_' + str(subID) + '.txt')
if oxi:
np.save(
path + '/Results/Subject_' + str(subID) + str(subNumber) +
str(nBlock) + '.npy', [oxi.recording, oxi.triggers])
return result_df
def clean_project_directory():
print(os.getcwd())
if os.path.isdir(os.getcwd() + '/metastore_db'):
shutil.rmtree(os.getcwd() + '/metastore_db', ignore_errors=True)
if os.path.exists(os.getcwd() + '/derby.log'):
os.remove(os.get_cwd() + '/derby.log')
def apply(registery, funcname, num_workers=0, **kwargs):
print(ub.color_text('--- APPLY {} ---'.format(funcname), 'white'))
print(' * num_workers = {!r}'.format(num_workers))
if num_workers == 0:
processed_repos = []
for repo in registery.repos:
print(ub.color_text('--- REPO = {} ---'.format(repo), 'blue'))
try:
getattr(repo, funcname)(**kwargs)
except DirtyRepoError:
print(
ub.color_text('Ignoring dirty repo={}'.format(repo),
'red'))
processed_repos.append(repo)
else:
from concurrent import futures
# with futures.ThreadPoolExecutor(max_workers=num_workers) as pool:
with futures.ProcessPoolExecutor(max_workers=num_workers) as pool:
tasks = []
for i, repo in enumerate(registery.repos):
future = pool.submit(worker, repo, funcname, kwargs)
future.repo = repo
tasks.append(future)
processed_repos = []
for future in futures.as_completed(tasks):
repo = future.repo
print(
ub.color_text('--- REPO = {} ---'.format(repo),
'blue'))
try:
repo = future.result()
except DirtyRepoError:
print(
ub.color_text(
'Ignoring dirty repo={}'.format(repo), 'red'))
else:
print(repo._getlogs())
processed_repos.append(repo)
print(
ub.color_text('--- FINISHED APPLY {} ---'.format(funcname),
'white'))
SHOW_CMDLOG = 1
if SHOW_CMDLOG:
print('LOGGED COMMANDS')
import os
ORIG_CWD = MY_CWD = os.getcwd()
for repo in processed_repos:
print('# --- For repo = {!r} --- '.format(repo))
for t in repo._logged_cmds:
cmd, cwd = t
if cwd is None:
cwd = os.get_cwd()
if cwd != MY_CWD:
print('cd ' + ub.shrinkuser(cwd))
MY_CWD = cwd
print(cmd)
print('cd ' + ub.shrinkuser(ORIG_CWD))
parser.add_argument(
'--puzzle',
help='Which puzzle to generate. All are generated if not given.',
type=str)
parser.add_argument('--puzzle_folder',
help='Where to dump puzzle files.',
type=str)
parser.add_argument('--preview',
help='This is used for debugging purposes.',
type=str)
parser.add_argument(
'--solve',
help=
'If true, try to generate a solution to the puzzle in the form of a stab-chain.',
action='store_true')
args = parser.parse_args()
puzzle_folder = args.puzzle_folder if args.puzzle_folder is not None else os.get_cwd(
)
os.makedirs(puzzle_folder, exist_ok=True)
for puzzle_class in Puzzle.__subclasses__():
puzzle = puzzle_class()
if args.puzzle is not None and puzzle.Name() != args.puzzle:
continue
print(
'======================================================================='
)
print('Processing: ' + puzzle.Name())
puzzle.Generate(puzzle_folder, args.solve, args.preview)
def roistat_tomat(roistat, localizer, conditions, conditions_keys, contrast, thr, fwhm, dof, subjs_id, subjs_sex, resolution, affine, save=False, save_dir=None):
df = roistat.df
odf = DataFrame(index=subjs_id)
odf = odf.reset_index().merge(df.reset_index(), how='left', on='index').set_index('index')
d = {}
d['info'] = {}
d['subj'] = {}
d['geo'] = {}
d['mag'] = {}
d['rlat'] = {}
d['info']['name'] = roistat.name
d['info']['localizer'] = localizer
d['info']['cond'] = np.array(conditions, dtype=np.object)
d['info']['contrast'] = contrast
d['info']['thr'] = thr
d['info']['fwhm'] = fwhm
d['info']['flag'] = np.array((~np.isnan(odf.size)).astype(np.bool))
d['info']['dof'] = dof
d['subj']['id'] = np.array(subjs_id, dtype=np.object)
d['subj']['sex'] = subjs_sex
d['geo']['size'] = (odf.size*resolution[0]*resolution[1]*resolution[2]).tolist()
peak = odf['peak']
center = odf['center']
gcenter = odf['gcenter']
null_mask = odf['size'].isnull()
t = odf[null_mask]
dummy_series = Series([[np.nan]*3]*len(t),index=t.index)
peak[null_mask] = dummy_series
center[null_mask] = dummy_series
gcenter[null_mask] = dummy_series
peak = np.array(peak.tolist())
center = np.array(center.tolist())
gcenter = np.array(gcenter.tolist())
d['geo']['peak'] = apply_affine_group(peak, affine, np.float)
d['geo']['center'] = apply_affine_group(center, affine, np.float)
d['geo']['gcenter'] = apply_affine_group(gcenter, affine, np.float)
d['geo']['subj_dice'] = roistat.between_subj_relations['dice'].relation_matrix
zkeys = ['Z'+key for key in conditions_keys]
tkeys = ['T'+key for key in conditions_keys]
bkeys = ['B'+key for key in conditions_keys]
ekeys = ['E'+key for key in conditions_keys]
d['mag']['pt'] = np.vstack([getattr(odf, key) for key in ['peak_'+key for key in tkeys]]).T
d['mag']['pz'] = np.vstack([getattr(odf, key) for key in ['peak_'+key for key in zkeys]]).T
d['mag']['pb'] = np.vstack([getattr(odf, key) for key in ['peak_'+key for key in bkeys]]).T
d['mag']['pe'] = np.vstack([getattr(odf, key) for key in ['peak_'+key for key in ekeys]]).T
d['mag']['rt'] = np.vstack([getattr(odf, key) for key in ['roi_'+key for key in tkeys]]).T
d['mag']['rz'] = np.vstack([getattr(odf, key) for key in ['roi_'+key for key in zkeys]]).T
d['mag']['rb'] = np.vstack([getattr(odf, key) for key in ['roi_'+key for key in bkeys]]).T
d['mag']['re'] = np.vstack([getattr(odf, key) for key in ['roi_'+key for key in ekeys]]).T
d['mag']['stm'] = np.vstack([getattr(odf, key) for key in ['mean_'+key for key in tkeys]]).T
d['mag']['szm'] = np.vstack([getattr(odf, key) for key in ['mean_'+key for key in zkeys]]).T
d['mag']['sbm'] = np.vstack([getattr(odf, key) for key in ['mean_'+key for key in bkeys]]).T
d['mag']['stsd'] = np.vstack([getattr(odf, key) for key in ['std_'+key for key in tkeys]]).T
d['mag']['szsd'] = np.vstack([getattr(odf, key) for key in ['std_'+key for key in zkeys]]).T
d['mag']['sbsd'] = np.vstack([getattr(odf, key) for key in ['std_'+key for key in bkeys]]).T
d['rlat']['overlap'] = roistat.anat_relations['overlap_HOcort_thr0'].relation_matrix
if save:
if save_dir is None:
save_dir = os.get_cwd()
save_dir = os.path.join(save_dir, roistat.name)
make_dir(save_dir)
outfile = os.path.join(save_dir, 'roi.mat')
sio.savemat(outfile, {'roi':d})
return d
import os
import os.path
from PIL import Image
work_dir = os.get_cwd()
def imgstich():
try:
empty = []
image_dir = os.path.abspath("/home/caratred/Downloads/combine")
print(image_dir)
# list all files in directory
files = os.listdir(image_dir)
print(files)
# # get all PNGs
# png_files = filter(lambda x: x.endswith(".jpeg"), files)
# # make file paths absolute
# print(png_files,".....///")
# image_files = map(lambda x: os.sep.join([image_dir, x]),files)
for x in files:
empty.append(os.sep.join([image_dir, x]))
print(empty, ",,,,,,")
n_files = len(empty)
# print (n_files)
target_img = None
n_targets = 0
collage_saved = False
# if rm_father_ic:
# os.remove('ic/ic1800x1800.npz')
return txt
def get_txt_lst(txt_id1, width, height, worker_dir, **kwargs):
txt_in = download_txt(txt_id1, worker_dir, **kwargs)
array_lst = chunk_array(txt_in, width, height, typeout='float64')
return array_lst
def get_txt(txt_id1, txt_id2, width, height, worker_dir, **kwargs):
array_lst = get_txt_lst(txt_id1, width, height, worker_dir, **kwargs)
# N=len(array_lst)
try:
txt = array_lst[txt_id2]
except IndexError as e:
import random
print(f'IndexError for {(width,txt_id1,txt_id2)}')
print(e)
txt_id2 = random.randint(0, len(array_lst) - 1)
print(f'Choosing txt_id2={txt_id2}...')
txt = array_lst[txt_id2] #-1]
return txt
if __name__ == '__main__':
worker_dir = os.get_cwd()
for txt_id in sys.argv[1:]:
download_txt(txt_id, worker_dir)
from flaskext.sqlalchemy import SQLAlchemy
from flaskext.script import Manager
from flask.ext.celery import install_commands, Celery
from flaskext.mail import Mail
__all__ = [
'app',
'db',
'mail',
]
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
if 'INSTANCE_PATH' in os.environ:
instance_path = os.environ['INSTANCE_PATH']
cwd = os.get_cwd()
if not instance_path.startswith('/'):
instance_path = os.path.abspath(os.path.join(cwd, instance_path))
else:
instance_path = os.path.abspath(os.path.join(os.path.dirname(__file__)))
app = Flask(__name__, instance_relative_config=True, instance_path=instance_path)
app.config.from_pyfile('application.cfg')
db = SQLAlchemy(app)
from wedding.utils import debug
debug.log_queries(app)
