def upload_boss_image(self, img, offset):
shape = Vec(*img.shape[:3])
offset = Vec(*offset)
bounds = Bbox(offset, shape + offset)
if bounds.subvoxel():
raise exceptions.EmptyRequestException(
'Requested less than one pixel of volume. {}'.format(bounds))
x_rng = [bounds.minpt.x, bounds.maxpt.x]
y_rng = [bounds.minpt.y, bounds.maxpt.y]
z_rng = [bounds.minpt.z, bounds.maxpt.z]
layer_type = 'image' if self.layer_type == 'unknown' else self.layer_type
chan = ChannelResource(
collection_name=self.path.bucket,
experiment_name=self.path.dataset,
name=self.path.layer, # Channel
type=layer_type,
datatype=self.dtype,
)
if img.shape[3] == 1:
img = img.reshape(img.shape[:3])
rmt = BossRemote(boss_credentials)
img = img.T
img = np.asfortranarray(img.astype(self.dtype))
rmt.create_cutout(chan, self.mip, x_rng, y_rng, z_rng, img)
def __init__(self, **kwargs):
"""
Create a new RelayStorageManager.
Arguments:
block_size: How much data should go in each file
"""
self.block_size = kwargs.get("block_size", (256, 256, 16))
if "next_layer" in kwargs:
self._next = kwargs["next_layer"]
self.is_terminal = False
else:
self.is_terminal = True
if "boss_remote" in kwargs:
self.boss_remote = kwargs["boss_remote"]
elif "upstream_uri" in kwargs:
self.token = kwargs.get("token", "public")
self.boss_remote = BossRemote({
"host":
kwargs["upstream_uri"],
"protocol":
kwargs.get("protocol", "http"),
"token":
kwargs.get("token", "public"),
})
def setup(self, parameters):
""" Method to load the file for uploading data. Assumes intern token is set via environment variable or config
default file
Args:
parameters (dict): Parameters for the dataset to be processed
MUST HAVE THE CUSTOM PARAMETERS: "x_offset": offset to apply when querying the Boss
"y_offset": offset to apply when querying the Boss
"z_offset": offset to apply when querying the Boss
"x_tile": size of a tile in x dimension
"y_tile": size of a tile in y dimension
"collection": source collection
"experiment": source experiment
"channel": source channel
"resolution": source resolution
Returns:
None
"""
self.parameters = parameters
self.remote = BossRemote()
self.channel = ChannelResource(self.parameters["channel"],
self.parameters["collection"],
self.parameters["experiment"])
self.channel = self.remote.get_project(self.channel)
def __init__(self, boss: BossRemote = None):
if boss is None:
try:
boss = BossRemote()
except:
boss = BossRemote(_DEFAULT_BOSS_OPTIONS)
self.boss = boss
def test_array_instantiation_with_channel(self):
"""
Array can be instantiated.
.
"""
boss = BossRemote(_DEFAULT_BOSS_OPTIONS)
_ = array(boss.get_channel("cc", "kasthuri2015", "em"))
def __init__(self,
host,
token,
collection,
experiment,
requested_channels,
x_range=None,
y_range=None,
z_range=None,
resolution=0):
self._bossRemote = BossRemote({
'protocol': 'https',
'host': host,
'token': token
})
self.collection = collection
self.experiment = experiment
self.resolution = resolution
self.channels = self._bossRemote.list_channels(collection, experiment)
if len(requested_channels) == 0:
self.requested_channels = self.channels
else:
self.requested_channels = requested_channels
self._get_coord_frame_details()
# validate range
#if not self.correct_range(z_range, y_range, x_range):
# raise Exception("Error: Inccorect dimension range")
self.x_range = x_range or [0, self.max_dimensions[2]]
self.y_range = y_range or [0, self.max_dimensions[1]]
self.z_range = z_range or [0, self.max_dimensions[0]]
def push_tif():
# message1 = request.form['channel']
#if message1:
# print(message1)
col = request.form["collection"]
exp = request.form["experiment"]
channel = request.form["channel"]
dtype = request.form["datatype"]
host,token = get_host_token()
x_range = [int(request.form["xstart"]),int(request.form["xstop"])]
y_range = [int(request.form["ystart"]),int(request.form["ystop"])]
z_range = [int(request.form["zstart"]),int(request.form["zstop"])]
remote = BossRemote('./neurodata.cfg')
voxel_size = '1 1 1'
voxel_unit = 'micrometers'
channel_resource = ChannelResource(channel, col, exp, 'image', '', 0, dtype, 0)
project = remote.get_project(channel_resource)
my_file = request.form["file"]
my_array = np.array(io.imread('./DATA/'+my_file)).astype(np.uint8)
for z in range(z_range[0],z_range[1]):
remote.create_cutout(channel_resource, 0, (x_range[0],x_range[1]), (y_range[0],y_range[1]), (z,z+1), my_array[z].reshape(-1,my_array.shape[1],my_array.shape[2]))
return 'Successfully pushed'
def test_init_with_config_dict(self):
config = {
"protocol": "https",
"host": "api.test.com",
"token": "asdlsdj2192isja"
}
rmt = BossRemote(config)
actual_prj = dict(rmt._config.items("Default"))
self.assertEqual('https', actual_prj[CONFIG_PROTOCOL])
self.assertEqual('api.test.com', actual_prj[CONFIG_HOST])
self.assertEqual('asdlsdj2192isja', actual_prj[CONFIG_TOKEN])
actual_meta = dict(rmt._config.items("Default"))
self.assertEqual('https', actual_meta[CONFIG_PROTOCOL])
self.assertEqual('api.test.com', actual_meta[CONFIG_HOST])
self.assertEqual('asdlsdj2192isja', actual_meta[CONFIG_TOKEN])
actual_vol = dict(rmt._config.items("Default"))
self.assertEqual('https', actual_vol[CONFIG_PROTOCOL])
self.assertEqual('api.test.com', actual_vol[CONFIG_HOST])
self.assertEqual('asdlsdj2192isja', actual_vol[CONFIG_TOKEN])
rmt.token_metadata = actual_meta[CONFIG_TOKEN]
rmt.token_volume = actual_vol[CONFIG_TOKEN]
rmt.token_project = actual_prj[CONFIG_TOKEN]
def setUp(self):
config = {
"protocol": "https",
"host": "test.theboss.io",
"token": "my_secret"
}
self.remote = BossRemote(config)
def test_array_instantiation_dtype(self):
"""
Array can be instantiated with type.
.
"""
boss = BossRemote(_DEFAULT_BOSS_OPTIONS)
test_array = array(boss.get_channel("cc", "kasthuri2015", "em"))
self.assertEqual(test_array.dtype, "uint8")
def __init__(self, collection_name):
"""
Constructor
"""
self.collection_name = collection_name
try:
self.rmt = BossRemote()
except:
print('Unexpected Error:', sys.exc_info()[0])
def __init__(self, host, token, collection, experiment):
self._bossRemote = BossRemote({'protocol': 'https',
'host': host,
'token': token})
self.collection = collection
self.experiment = experiment
self.channels = self._bossRemote.list_channels(collection, experiment)
self.channels.remove('empty') #Delete "empty" channel
self._get_coord_frame_details()
def setup_remote(self):
if self.ingest_job.boss_config_file:
return BossRemote(self.ingest_job.boss_config_file)
else:
# try to load from environment variable
token = os.environ['BOSS_TOKEN']
protocol = 'https'
host = 'api.boss.neurodata.io'
config_dict = {'token': token, 'protocol': protocol, 'host': host}
return BossRemote(config_dict)
def delete_channel(remote: BossRemote, channel, coll_name=None, exp_name=None):
chan_obj = None
if isinstance(channel, ChannelResource):
chan_obj = channel
elif isinstance(channel, str) and coll_name is not None and exp_name is not None:
chan_name = channel
chan_obj = remote.get_project(ChannelResource(name=chan_name, experiment_name=exp_name))
if chan_obj is not None:
print('Deleting channel "{0}"...'.format(chan_obj.name))
remote.delete_project(chan_obj)
def fetch_info(self):
experiment = ExperimentResource(name=self.path.dataset,
collection_name=self.path.bucket)
rmt = BossRemote(boss_credentials)
experiment = rmt.get_project(experiment)
coord_frame = CoordinateFrameResource(name=experiment.coord_frame)
coord_frame = rmt.get_project(coord_frame)
channel = ChannelResource(self.path.layer, self.path.bucket,
self.path.dataset)
channel = rmt.get_project(channel)
unit_factors = {
'nanometers': 1,
'micrometers': 1e3,
'millimeters': 1e6,
'centimeters': 1e7,
}
unit_factor = unit_factors[coord_frame.voxel_unit]
cf = coord_frame
resolution = [cf.x_voxel_size, cf.y_voxel_size, cf.z_voxel_size]
resolution = [int(round(_)) * unit_factor for _ in resolution]
bbox = Bbox((cf.x_start, cf.y_start, cf.z_start),
(cf.x_stop, cf.y_stop, cf.z_stop))
bbox.maxpt = bbox.maxpt
layer_type = 'unknown'
if 'type' in channel.raw:
layer_type = channel.raw['type']
info = CloudVolume.create_new_info(
num_channels=1,
layer_type=layer_type,
data_type=channel.datatype,
encoding='raw',
resolution=resolution,
voxel_offset=bbox.minpt,
volume_size=bbox.size3(),
chunk_size=(512, 512, 16), # fixed in s3 implementation
)
each_factor = Vec(2, 2, 1)
if experiment.hierarchy_method == 'isotropic':
each_factor = Vec(2, 2, 2)
factor = each_factor.clone()
for _ in range(1, experiment.num_hierarchy_levels):
self.add_scale(factor, info=info)
factor *= each_factor
return info
def delete_coord_frame(remote: BossRemote, coord_frame):
frame_obj = None
# frame_name = None
if isinstance(coord_frame, CoordinateFrameResource):
frame_obj = coord_frame
# frame_name = coord_frame.name
elif isinstance(coord_frame, str):
frame_name = coord_frame
frame_obj = remote.get_project(CoordinateFrameResource(name=frame_name))
if frame_obj is not None:
print('Deleting coordinate frame "{0}"...'.format(frame_obj.name))
remote.delete_project(frame_obj)
def __init__(self, collection_name):
"""
Constructor:
Takes the following argument:
:param collection_name: name of the collection in BOSS
:type collection_name: string
"""
self.collection_name = collection_name
try:
self.rmt = BossRemote()
except:
print('Unexpected Error:', sys.exc_info()[0])
def test_can_retrieve_correct_u64_data(self):
data = array("bossdb://kasthuri2015/em/3cylneuron_v1")
boss = BossRemote(_DEFAULT_BOSS_OPTIONS)
get_cutout_data = boss.get_cutout(
boss.get_channel("3cylneuron_v1", "kasthuri2015", "em"),
0,
[6000, 6200],
[12000, 12500],
[923, 924],
)
self.assertTrue(
(get_cutout_data == data[923:924, 12000:12500, 6000:6200]).all()
)
def set_experiment_resource(remote: BossRemote, params: dict) -> ExperimentResource:
"""Use the arguments in the class config to create an experiment resource object"""
if 'name' not in params:
params['name'] = 'experiment{0}'.format(hex(round(time.time()))[2:])
param_names = [str(p.name) for p in inspect.signature(ExperimentResource).parameters.values()]
filtered_params = {k: v for k, v in list(params.items()) if k in param_names} # Filter unexpected arguments
exp_resource = ExperimentResource(**filtered_params)
if exp_resource.name in remote.list_experiments(exp_resource.coll_name):
experiment = remote.update_project(exp_resource.name, exp_resource)
print('Updated experiment {0}'.format(exp_resource.name))
else:
experiment = remote.create_project(exp_resource)
print('Created experiment {0}'.format(exp_resource.name))
return experiment
def set_coordinate_frame_resource(remote: BossRemote, params: dict) -> CoordinateFrameResource:
"""Use the arguments in the class config to create a frame resource object"""
if 'name' not in params:
params['name'] = 'frame{0}'.format(hex(round(time.time()))[2:])
param_names = [str(p.name) for p in inspect.signature(CoordinateFrameResource).parameters.values()]
filtered_params = {k: v for k, v in list(params.items()) if k in param_names} # Filter unexpected arguments
frame_resource = CoordinateFrameResource(**filtered_params)
if frame_resource.name in remote.list_coordinate_frames():
coordinate_frame = remote.update_project(frame_resource.name, frame_resource)
print('Updated frame {0}'.format(frame_resource.name))
else:
coordinate_frame = remote.create_project(frame_resource)
print('Created frame {0}'.format(frame_resource.name))
return coordinate_frame
def set_channel_resource(remote: BossRemote, params: dict) -> ChannelResource:
"""Use the arguments in the class config to create a channel resource object"""
if 'name' not in params:
params['name'] = 'channel{0}'.format(hex(round(time.time()))[2:])
param_names = [str(p.name) for p in inspect.signature(ChannelResource).parameters.values()]
filtered_params = {k: v for k, v in list(params.items()) if k in param_names} # Filter unexpected arguments
chan_resource = ChannelResource(**filtered_params)
if chan_resource.name in remote.list_channels(chan_resource.coll_name, chan_resource.exp_name):
channel = remote.update_project(chan_resource.name, chan_resource)
print('Updated channel {0}'.format(chan_resource.name))
else:
channel = remote.create_project(chan_resource)
print('Created channel {0}'.format(chan_resource.name))
return channel
def download(self, bbox, mip, parallel=1, renumber=False):
if parallel != 1:
raise ValueError("Only parallel=1 is supported for boss.")
elif renumber != False:
raise ValueError("Only renumber=False is supported for boss.")
bounds = Bbox.clamp(bbox, self.meta.bounds(mip))
if self.autocrop:
image, bounds = autocropfn(self.meta, image, bounds, mip)
if bounds.subvoxel():
raise exceptions.EmptyRequestException(
'Requested less than one pixel of volume. {}'.format(bounds))
x_rng = [bounds.minpt.x, bounds.maxpt.x]
y_rng = [bounds.minpt.y, bounds.maxpt.y]
z_rng = [bounds.minpt.z, bounds.maxpt.z]
layer_type = 'image' if self.meta.layer_type == 'unknown' else self.meta.layer_type
chan = ChannelResource(
collection_name=self.meta.path.bucket,
experiment_name=self.meta.path.dataset,
name=self.meta.path.layer, # Channel
type=layer_type,
datatype=self.meta.data_type,
)
rmt = BossRemote(boss_credentials)
cutout = rmt.get_cutout(chan, mip, x_rng, y_rng, z_rng, no_cache=True)
cutout = cutout.T
cutout = cutout.astype(self.meta.dtype)
cutout = cutout[::steps.x, ::steps.y, ::steps.z]
if len(cutout.shape) == 3:
cutout = cutout.reshape(tuple(list(cutout.shape) + [1]))
if self.bounded or self.autocrop or bounds == bbox:
return VolumeCutout.from_volume(self.meta, mip, cutout, bounds)
# This section below covers the case where the requested volume is bigger
# than the dataset volume and the bounds guards have been switched
# off. This is useful for Marching Cubes where a 1px excess boundary
# is needed.
shape = list(bbox.size3()) + [cutout.shape[3]]
renderbuffer = np.zeros(shape=shape, dtype=self.meta.dtype, order='F')
shade(renderbuffer, bbox, cutout, bounds)
return VolumeCutout.from_volume(self.meta, mip, renderbuffer, bbox)
def test_init_with_default_file(self):
rmt = BossRemote(self.default_cfg)
actual_default = dict(rmt._config.items("Default"))
self.assertEqual('https', actual_default[CONFIG_PROTOCOL])
self.assertEqual('default.theboss.io', actual_default[CONFIG_HOST])
self.assertEqual('default_secret_token', actual_default[CONFIG_TOKEN])
actual_meta = dict(rmt._config.items(CONFIG_METADATA_SECTION))
self.assertEqual('file', actual_meta[CONFIG_PROTOCOL])
self.assertEqual('meta.theboss.io', actual_meta[CONFIG_HOST])
self.assertEqual('my_secret_token2', actual_meta[CONFIG_TOKEN])
rmt.token_metadata = actual_meta[CONFIG_TOKEN]
rmt.token_volume = actual_default[CONFIG_TOKEN]
rmt.token_project = actual_default[CONFIG_TOKEN]
def initialize(cls):
"""Initialization for each test.
Called by both setUp() and setUpClass().
"""
cls.rmt = BossRemote('test.cfg', API_VER)
# Turn off SSL cert verification. This is necessary for interacting with
# developer instances of the Boss.
cls.rmt.project_service.session_send_opts = {'verify': False}
cls.rmt.metadata_service.session_send_opts = {'verify': False}
cls.rmt.volume_service.session_send_opts = {'verify': False}
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
coll_name = 'coll2309_{}'.format(random.randint(0, 9999))
cls.coll = CollectionResource(coll_name, 'bar')
cf_name = 'MetaFrame{}'.format(random.randint(0, 9999))
cls.coord = CoordinateFrameResource(cf_name, 'Test coordinate frame.',
0, 10, -5, 5, 3, 6, 1, 1, 1,
'nanometers', 1, 'nanoseconds')
cls.exp = ExperimentResource('myMetaExp2309', cls.coll.name,
cls.coord.name, 'my experiment', 1,
'isotropic', 1)
cls.chan = ChannelResource('myTestMetaChan', cls.coll.name,
cls.exp.name, 'image', 'test channel', 0,
'uint8', 0)
def setUpClass(cls):
"""Do an initial DB clean up in case something went wrong the last time.
If a test failed really badly, the DB might be in a bad state despite
attempts to clean up during tearDown().
"""
warnings.filterwarnings('ignore')
cls.rmt = BossRemote('test.cfg', API_VER)
# Turn off SSL cert verification. This is necessary for interacting with
# developer instances of the Boss.
cls.rmt.project_service.session_send_opts = {'verify': False}
cls.rmt.metadata_service.session_send_opts = {'verify': False}
cls.rmt.volume_service.session_send_opts = {'verify': False}
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
cls.create_grp_name = 'int_test_group{}'.format(random.randint(0, 9999))
cls.existing_grp_name = 'int_test_group_exists{}'.format(random.randint(0, 9999))
cls.rmt.create_group(cls.existing_grp_name)
cls.user_name = 'bossadmin'
# Create a new user because the user tests run under, will
# automatically be a member and maintainer of any groups created
# during testing.
cls.created_user = '******'.format(random.randint(0, 9999))
password = '******'
cls.rmt.add_user(cls.created_user, 'John', 'Doeski', 'jdoe{}@rime.com'.format(random.randint(0, 9999)),
password)
token = cls.get_access_token(cls.created_user, password)
cls.login_user(token)
def getChan(CONFIG_FILE, coll, exp):
config = configparser.ConfigParser()
config.read(CONFIG_FILE)
TOKEN = config['Default']['token']
boss_url = ''.join((config['Default']['protocol'], '://',
config['Default']['host'], '/v1/'))
#print(boss_url)
#'https://api.boss.neurodata.io/v1/'
#intern
rem = BossRemote(CONFIG_FILE)
chan = rem.list_channels(coll, exp)
out = list(
filter(lambda x: re.search(r'^(?!annotation|empty|EM)', x), chan))
em = list(filter(lambda x: re.search(r'(EM*)', x), chan))
return (out + em)
class NeuroDataResource:
def __init__(self, host, token, collection, experiment, chanList):
self._collection = collection
self._experiment = experiment
self._bossRemote = BossRemote({'protocol':'https',
'host':host,
'token':token})
self._chanList = {}
for chanDict in chanList:
try:
self._chanList[chanDict['name']] = ChannelResource(chanDict['name'],
collection,
experiment,
'image',
datatype=chanDict['dtype'])
except:
#TODO error handle here
raise
def get_cutout(self, chan, zRange=None, yRange=None, xRange=None):
if not chan in self._chanList.keys():
print('Error: Channel Not Found in this Resource')
return
if zRange is None or yRange is None or xRange is None:
print('Error: You must supply zRange, yRange, xRange kwargs in list format')
data = self._bossRemote.get_cutout(self._chanList[chan],
0,
xRange,
yRange,
zRange)
return data
def __init__(self, ingest_job, get_only=True):
self.ingest_job = ingest_job
self.coord_frame_name = '_'.join(
(ingest_job.coll_name, ingest_job.exp_name))
self.rmt = BossRemote(self.ingest_job.boss_config_file)
self.coll_resource = self.setup_boss_collection(get_only=get_only)
self.coord_frame_resource = self.setup_boss_coord_frame(
get_only=get_only)
self.exp_resource = self.setup_boss_experiment(get_only=get_only)
self.ch_resource = self.setup_boss_channel(get_only=get_only)
def delete_collection(remote: BossRemote, collection):
coll_obj = None
coll_name = None
if isinstance(collection, CollectionResource):
coll_obj = collection
coll_name = collection.name
elif isinstance(collection, str):
coll_name = collection
coll_obj = remote.get_project(CollectionResource(name=coll_name))
if coll_name is not None:
print('Deleting experiments of collection "{0}"...'.format(coll_name))
exp_names = remote.list_experiments(coll_name)
for n in exp_names:
delete_experiment(remote, n, coll_name)
if coll_obj is not None:
print('Deleting collection "{0}"...'.format(coll_name))
remote.delete_project(coll_obj)
def main():
config = sys.argv[1]
config_p = configparser.ConfigParser()
config_p.read(config)
rmt = BossRemote(config)
viz_link = register_data(rmt, config_p)
logfile = config_p['Default']['logfile']
write_to_logfile('registration viz link: {}'.format(viz_link), logfile)
def __init__(self, host, token, collection, experiment, chanList):
self._collection = collection
self._experiment = experiment
self._bossRemote = BossRemote({'protocol':'https',
'host':host,
'token':token})
self._chanList = {}
for chanDict in chanList:
try:
self._chanList[chanDict['name']] = ChannelResource(chanDict['name'],
collection,
experiment,
'image',
datatype=chanDict['dtype'])
except:
#TODO error handle here
raise
def _boss_cutout(self, requested_bbox, steps, channel_slice=slice(None)):
bounds = Bbox.clamp(requested_bbox, self.bounds)
if bounds.subvoxel():
raise exceptions.EmptyRequestException(
'Requested less than one pixel of volume. {}'.format(bounds))
x_rng = [bounds.minpt.x, bounds.maxpt.x]
y_rng = [bounds.minpt.y, bounds.maxpt.y]
z_rng = [bounds.minpt.z, bounds.maxpt.z]
layer_type = 'image' if self.layer_type == 'unknown' else self.layer_type
chan = ChannelResource(
collection_name=self.path.bucket,
experiment_name=self.path.dataset,
name=self.path.layer, # Channel
type=layer_type,
datatype=self.dtype,
)
rmt = BossRemote(boss_credentials)
cutout = rmt.get_cutout(chan,
self.mip,
x_rng,
y_rng,
z_rng,
no_cache=True)
cutout = cutout.T
cutout = cutout.astype(self.dtype)
cutout = cutout[::steps.x, ::steps.y, ::steps.z]
if len(cutout.shape) == 3:
cutout = cutout.reshape(tuple(list(cutout.shape) + [1]))
if self.bounded or self.autocrop or bounds == requested_bbox:
return VolumeCutout.from_volume(self, cutout, bounds)
# This section below covers the case where the requested volume is bigger
# than the dataset volume and the bounds guards have been switched
# off. This is useful for Marching Cubes where a 1px excess boundary
# is needed.
shape = list(requested_bbox.size3()) + [cutout.shape[3]]
renderbuffer = np.zeros(shape=shape, dtype=self.dtype, order='F')
txrx.shade(renderbuffer, requested_bbox, cutout, bounds)
return VolumeCutout.from_volume(self, renderbuffer, requested_bbox)
def main():
config = sys.argv[1]
config_p = configparser.ConfigParser()
config_p.read(config)
rmt = BossRemote(config)
viz_link = detect_cells(rmt, config_p)
logfile = config_p['Default']['logfile']
boss_util.write_to_logfile('cell_detection viz link: {}'.format(viz_link),logfile)
class NeuroDataResource:
def __init__(self, host, token, collection, experiment, chanList):
self._collection = collection
self._experiment = experiment
self._bossRemote = BossRemote({'protocol':'https',
'host':host,
'token':token})
self._chanList = {}
for chanDict in chanList:
try:
self._chanList[chanDict['name']] = ChannelResource(chanDict['name'],
collection,
experiment,
'image',
datatype=chanDict['dtype'])
except:
#TODO error handle here
raise
def get_cutout(self, chan, zRange=None, yRange=None, xRange=None):
if not chan in self._chanList.keys():
print('Error: Channel Not Found in this Resource')
return
if zRange is None or yRange is None or xRange is None:
print('Error: You must supply zRange, yRange, xRange kwargs in list format')
data = self._bossRemote.get_cutout(self._chanList[chan],
0,
xRange,
yRange,
zRange)
return data
def save_img(self, fname, cutout, format = 'tif'):
'''
Saves a image as a tif or nii file
Leave the file type suffix out of fname
'''
if (not fname) or (type(fname) != str):
print('Error: Give valid filename')
if (not cutout) or type(cutout) != np.array:
print('Error: Give valid image cutout')
if format == 'tif':
max_grey_val = cutout.max(axis=1).max(axis=1).max()
dim = cutout.shape()
cutout_rgb = np.zeros((dim[0], dim[1], dim[2], 3))
for i in range(dim[0]):
for j in range(dim[1]):
for k in range(dim[2]):
normalized_rgb = int( 255 * (cutout[i][j][k]/max_grey_val) )
for p in range(3):
cutout_rgb[i][j][k][p] = normalized_rgb
imsave(fname+'.tif', cutout_rgb.astype(np.uint8))
else:
nifti_img = nib.Nifti1Image(cutout, np.eye(4))
nib.save(nifti_img, fname+'.nii')
def delete_experiment(remote: BossRemote, experiment, coll_name=None):
exp_obj = None
exp_name = None
if isinstance(experiment, ExperimentResource):
exp_obj = experiment
exp_name = experiment.name
coll_name = experiment.coll_name
elif isinstance(experiment, str) and coll_name is not None:
exp_name = experiment
exp_obj = remote.get_project(ExperimentResource(name=exp_name, collection_name=coll_name))
if exp_name is not None:
print('Deleting channels of experiment "{0}"...'.format(exp_name))
chan_names = remote.list_channels(coll_name, exp_name)
for n in chan_names:
delete_channel(remote, n, exp_name, coll_name)
if exp_obj is not None:
print('Deleting experiment "{0}"...'.format(exp_obj.name))
remote.delete_project(exp_obj)
def __init__(self, host, token, collection, experiment, requested_channels,
xRange,
yRange,
zRange):
self._bossRemote = BossRemote({'protocol': 'https',
'host': host,
'token': token})
self.collection = collection
self.experiment = experiment
if len(requested_channels) == 0:
self.requested_channels = self.channels
else:
self.requested_channels = requested_channels
self.channels = self._bossRemote.list_channels(collection, experiment)
self._get_coord_frame_details()
self.x_range = xRange
self.y_range = yRange
self.z_range = zRange
def main():
t_start_overall = time.time()
parser = argparse.ArgumentParser(description='Register a brain in the BOSS and upload it back in a new experiment.')
parser.add_argument('--collection', help='Name of collection to upload tif stack to', type=str)
parser.add_argument('--experiment', help='Name of experiment to upload tif stack to', type=str)
parser.add_argument('--channel', help='Name of channel to upload tif stack to. Default is new channel will be created unless otherwise specified. See --new_channel', type=str)
parser.add_argument('--config', help='Path to configuration file with Boss API token. Default: ~/.intern/intern.cfg', default=os.path.expanduser('~/.intern/intern.cfg'))
parser.add_argument('--scale', help='Scale at which to perform the bias correction. Default is 0.1 meaning 1/10th the size of the original image', default=0.1, type=float)
args = parser.parse_args()
# mm to um conversion factor
mm_to_um = 1000.0
# download image
rmt = BossRemote(cfg_file_or_dict=args.config)
# resolution level from 0-6
resolution_image = 0
image_isotropic = True
# downloading image
print('downloading experiment: {}, channel: {}...'.format(args.experiment, args.channel))
t1 = time.time()
img = download_image(rmt, args.collection, args.experiment, args.channel, res=resolution_image, isotropic=image_isotropic)
print("time to download image at res {} um: {} seconds".format(img.GetSpacing()[0] * mm_to_um, time.time()-t1))
print("correcting bias in image...")
t1 = time.time()
# scale = 0.05 # scale at which to perform bias correction
img_bc = preprocessor.correct_bias_field(img, scale=args.scale, niters=[100,100,100,100])
print("time to correct bias in image at res {} um: {} seconds".format(img.GetSpacing()[0] * mm_to_um * (1.0/args.scale), time.time()-t1))
# print("upsampling bias to match original size of image...")
# ch_rsc_og = create_channel_resource(rmt, args.channel, args.collection, args.experiment, new_channel=False)
# meta = get_xyz_extents(rmt, ch_rsc_og)
# spacing = np.array(meta[-1])/mm_to_um
# x_size = meta[0][1]
# y_size = meta[1][1]
# z_size = meta[2][1]
# size = (x_size, y_size, z_size)
#
# # recover bias
# bias_ds = img_bc / sitk.Cast(img, img_bc.GetPixelID())
#
# # Upsample bias
# bias = imgResample(bias_ds, spacing=spacing, size=img.GetSize())
#
# # apply bias to image
# img_bc = sitk.Cast(img, sitk.sitkFloat32) * sitk.Cast(bias, sitk.sitkFloat32)
#
print("uploading bias corrected image back to the BOSS")
new_channel = args.channel + '_bias_corrected'
ch_rsc_bc = create_channel_resource(rmt, new_channel, args.collection, args.experiment, datatype='uint16', type='image')
upload_to_boss(rmt, sitk.GetArrayFromImage(img_bc).astype('uint16'), ch_rsc_bc)
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import json
from intern.remote.boss import BossRemote
from intern.resource.boss.resource import *
CONFIG_FILE = "demo_cfg.json"
rmt = BossRemote("./boss.cfg")
# Load Configuration File
with open(os.path.join("./db_configs", CONFIG_FILE), 'rt') as cfg:
config = json.load(cfg)
# Create a collection
collection = CollectionResource(config["collection"]["name"], config["collection"]["description"])
try:
collection = rmt.create_project(collection)
except Exception as e:
collection = rmt.get_project(collection)
# Create a coord frame
coord = CoordinateFrameResource(config["coordinate_frame"]["name"],
config["coordinate_frame"]["description"],
def gen_urls(args):
config = {'protocol': 'https',
'host': args.hostname,
'token': args.token}
boss = BossRemote(config)
results = []
try:
if args.collection is not None:
collections = [args.collection]
else:
collections = boss.list_collections()
for collection in collections:
if args.experiment is not None:
experiments = [args.experiment]
else:
experiments = boss.list_experiments(collection)
for experiment in experiments:
if args.channel is not None:
channels = [args.channel]
else:
channels = boss.list_channels(collection, experiment)
exp = ExperimentResource(name = experiment,
collection_name = collection)
exp = boss.get_project(exp)
coord = CoordinateFrameResource(name = exp.coord_frame)
coord = boss.get_project(coord)
for channel in channels:
ch = ChannelResource(name = channel,
experiment_name = experiment,
collection_name = collection)
ch = boss.get_project(ch)
def check_range(name, var, start, stop):
start_, stop_ = map(int, var.split(':'))
if start_ < start:
fmt = "{} range start for {}/{}/{} is less than the coordinate frame, setting to minimum"
print(fmt.format(name, collection, experiment, channel))
start_ = start
if stop_ > stop:
fmt = "{} range stop for {}/{}/{} is greater than the coordinate frame, setting to maximum"
print(fmt.format(name, collection, experiment, channel))
stop_ = stop
return '{}:{}'.format(start_, stop_)
if args.x_range:
x = check_range('X', args.x_range, coord.x_start, coord.x_stop)
else:
x = (coord.x_start, coord.x_stop, args.min, args.max)
if args.y_range:
y = check_range('Y', args.y_range, coord.y_start, coord.y_stop)
else:
y = (coord.y_start, coord.y_stop, args.min, args.max)
if args.z_range:
z = check_range('Z', args.z_range, coord.z_start, coord.z_stop)
else:
z = (coord.z_start, coord.z_stop, args.min, args.max)
# Arguments to gen_url
results.append((args.hostname,
collection,
experiment,
channel,
0, x, y, z, None))
except Exception as e:
print("Error generating URLs: {}".format(e))
return results
# limitations under the License.
from intern.remote.boss import BossRemote
from intern.resource.boss.resource import *
# Script to create a group and give it read access to a channel
# #### SETUP
grp_name = 'my_team'
collection_name = "my_col"
experiment_name = "my_exp"
coord_frame_name = "my_coord"
channel_name = "my_chan"
# #### SETUP
rmt = BossRemote("./boss.cfg")
print('Creating group . . .')
try:
rmt.create_group(grp_name)
except Exception as e:
# Assume group already exists if an exception raised.
print(e)
# Get the resources
collection = CollectionResource(collection_name)
collection = rmt.get_project(collection)
experiment = ExperimentResource(experiment_name, collection_name, coord_frame_name)
experiment = rmt.get_project(experiment)
channel = ChannelResource(channel_name, collection_name, experiment_name)
channel = rmt.get_project(channel)
