def compute_residuals(self):
stack_dbconnection = renderapi.connect(**self.args['output_stack'])
match_dbconnection = renderapi.connect(**self.args['pointmatch'])
tspecs = [
renderapi.tilespec.get_tile_specs_from_z(
self.args['output_stack']['name'][0],
float(self.args['z1']),
render=stack_dbconnection)
]
if self.args['z1'] != self.args['z2']:
tspecs.append(
renderapi.tilespec.get_tile_specs_from_z(
self.args['output_stack']['name'][0],
float(self.args['z2']),
render=stack_dbconnection))
sectionIds = []
for t in tspecs:
sectionIds.append(t[0].layout.sectionId)
if len(sectionIds) == 1:
sectionIds.append(sectionIds[0])
if self.args['zoff'] != 0:
tmp = []
for sid in sectionIds:
try:
tmp.append(str(int(sid) + self.args['zoff']))
except ValueError:
tmp.append(sid)
sectionIds = tmp
matches = renderapi.pointmatch.get_matches_from_group_to_group(
self.args['pointmatch']['name'][0],
sectionIds[0],
sectionIds[1],
render=match_dbconnection)
self.p, self.q, self.p_transf, self.q_transf = \
transform_pq(tspecs, matches)
self.xy_ave = [
0.5 * (p + q) for p, q in zip(self.p_transf, self.q_transf)
]
self.xy_diff = [(p - q) for p, q in zip(self.p_transf, self.q_transf)]
self.rss = [
np.sqrt(np.power(x[:, 0], 2.0) + np.power(x[:, 1], 2.0))
for x in self.xy_diff
]
self.mx = ''
self.my = ''
self.mr = ''
self.ident = 'owner: %s' % self.args['output_stack']['owner']
self.ident += '\nproject: %s' % self.args['output_stack']['project']
self.ident += '\nstack: %s' % self.args['output_stack']['name'][0]
self.ident += '\n' + 'collection: %s' % self.args['pointmatch'][
'name'][0]
self.ident += '\n' + 'z1,z2: %d,%d' % (self.args['z1'],
self.args['z2'])
def test_apply_lens_correction_mask(render, stack_no_lc, stack_lc,
example_tform_dict, test_points,
tmpdir_factory):
params = {
"render": render_params,
"inputStack": stack_no_lc,
"outputStack": stack_lc,
"zs": [2266],
"transform": example_tform_dict,
"refId": None,
"pool_size": 5,
"overwrite_zlayer": True
}
# make a mask
tspecs = renderapi.tilespec.get_tile_specs_from_z(
params['inputStack'],
float(params['zs'][0]),
render=renderapi.connect(**params['render']))
mask_dir = str(tmpdir_factory.mktemp("make_mask"))
dx = 100
dy = 100
width = int(tspecs[0].width)
height = int(tspecs[0].height)
mask_coords = [[0, dy], [dx, 0], [width, 0], [width, height], [0, height]]
maskUrl = make_mask(mask_dir,
width,
height,
mask_coords,
mask_file=None,
basename='mymask.png')
params['maskUrl'] = maskUrl
out_fn = 'test_ALC_out.json'
mod = ApplyLensCorrection(input_data=params,
args=['--output_json', out_fn])
mod.run()
tspecs = renderapi.tilespec.get_tile_specs_from_z(
params['outputStack'],
float(params['zs'][0]),
render=renderapi.connect(**params['render']))
for t in tspecs:
for lvl, mm in t.ip.items():
assert (mm.maskUrl is not None)
mpath = urllib.parse.unquote(
urllib.parse.urlparse(mm.maskUrl).path)
assert (os.path.isfile(mpath))
mask = imageio.imread(mpath)
assert (mask.shape[0] == height / (2**int(lvl)))
assert (mask.shape[1] == width / (2**int(lvl)))
def compute_residuals(self):
stack_dbconnection = renderapi.connect(**self.args['output_stack'])
match_dbconnection = renderapi.connect(**self.args['pointmatch'])
#get the tilespecs and pointmatches
tspecs = [
renderapi.tilespec.get_tile_specs_from_z(
self.args['output_stack']['name'],
float(self.args['z1']),
render=stack_dbconnection)
]
if self.args['z1'] != self.args['z2']:
tspecs.append(
renderapi.tilespec.get_tile_specs_from_z(
self.args['output_stack']['name'],
float(self.args['z2']),
render=stack_dbconnection))
matches = renderapi.pointmatch.get_matches_from_group_to_group(
self.args['pointmatch']['name'],
str(float(self.args['z1'])),
str(float(self.args['z2'])),
render=match_dbconnection)
self.p, self.q, self.p_transf, self.q_transf = transform_pq(
tspecs, matches)
self.xy_ave = [
0.5 * (p + q) for p, q in zip(self.p_transf, self.q_transf)
]
self.xy_diff = [(p - q) for p, q in zip(self.p_transf, self.q_transf)]
self.rss = [
np.sqrt(np.power(x[:, 0], 2.0) + np.power(x[:, 1], 2.0))
for x in self.xy_diff
]
self.mx = ''
self.my = ''
self.mr = ''
#self.rss = np.sqrt(np.power(self.xy_diff[0,:],2.0)+np.power(self.xy_diff[1,:],2.0))
#self.mx = '[min , max] ave +/- sig\n[%0.1f , %0.1f] %0.1f +/- %0.1f'%(self.xy_diff[0,:].min(),self.xy_diff[0,:].max(),self.xy_diff[0,:].mean(),self.xy_diff[0,:].std())
#self.my = '[min , max] ave +/- sig\n[%0.1f , %0.1f] %0.1f +/- %0.1f'%(self.xy_diff[1,:].min(),self.xy_diff[1,:].max(),self.xy_diff[1,:].mean(),self.xy_diff[1,:].std())
#self.mr = '[min , max] ave +/- sig\n[%0.1f , %0.1f] %0.1f +/- %0.1f'%(self.rss.min(),self.rss.max(),self.rss.mean(),self.rss.std())
self.ident = 'owner: %s' % self.args['output_stack']['owner']
self.ident += '\nproject: %s' % self.args['output_stack']['project']
self.ident += '\nstack: %s' % self.args['output_stack']['name']
self.ident += '\n' + 'collection: %s' % self.args['pointmatch']['name']
self.ident += '\n' + 'z1,z2: %d,%d' % (self.args['z1'],
self.args['z2'])
def test_filter_write(example):
# write to a new collection
params = dict(example)
params['output_match_collection'] = 'something_new'
fmod = run_and_check_output(params)
for z in fmod.args['zValues']:
m0 = renderapi.pointmatch.get_matches_within_group(
fmod.args['input_match_collection'],
str(float(z)),
render=renderapi.connect(**fmod.args['render']))
m1 = renderapi.pointmatch.get_matches_within_group(
fmod.args['output_match_collection'],
str(float(z)),
render=renderapi.connect(**fmod.args['render']))
assert(len(m0) == len(m1))
def gen_file_list(cross_dir, stack, n, match, ppf, logdir, render_connect_params, **kwargs):
optflow = defaults(n, **kwargs)
optflow["host"] = render_connect_params["host"]
optflow["port"] = render_connect_params["port"]
optflow["matchCollection"] = match
optflow["owner"] = render_connect_params["owner"]
render = renderapi.connect(**render_connect_params)
tilespecs = renderapi.tilespec.get_tile_specs_from_stack(
stack, render=render)
imageurls = {i.tileId: i.ip[0].imageUrl.split(":")[-1] for i in tilespecs}
for cross in glob("%s/*.json.gz" % (cross_dir)):
with gzip.open(cross) as f:
pairs = json.loads(f.read().decode("ascii"))
sub_pair_list = [pairs["neighborPairs"][i:i+ppf]
for i in range(0, len(pairs["neighborPairs"]), ppf)]
N_dict = {}
for count, sub_pairs in enumerate(sub_pair_list):
optflow["images"] = []
for pair in sub_pairs:
if logdir is not None:
if imageurls[pair["p"]["id"]] not in N_dict:
with open(logpath(logdir, imageurls[pair["p"]["id"]]), "r") as f:
N_dict[imageurls[pair["p"]["id"]]] = float(
next(f).split(" ")[0])
if imageurls[pair["q"]["id"]] not in N_dict:
with open(logpath(logdir, imageurls[pair["q"]["id"]]), "r") as f:
N_dict[imageurls[pair["q"]["id"]]] = float(
next(f).split(" ")[0])
if "sub_list" in kwargs:
if (int(float(pair["p"]["groupId"])) not in kwargs["sub_list"]) and (int(float(pair["q"]["groupId"])) not in kwargs["sub_list"]):
continue
print(pair["p"])
# if abs(float(pair["p"]["groupId"]) - float(pair["q"]["groupId"])) <= 9:
# continue
im_data = {}
im_data["p"] = imageurls[pair["p"]["id"]]
im_data["q"] = imageurls[pair["q"]["id"]]
im_data["pId"] = pair["p"]["id"]
im_data["qId"] = pair["q"]["id"]
im_data["pGroupId"] = pair["p"]["groupId"]
im_data["qGroupId"] = pair["q"]["groupId"]
im_data["output_name"] = pair["p"]["id"] + \
"_" + pair["q"]["id"]
if logdir is not None:
col_p = int(imageurls[pair["p"]["id"]].split("-")[-2])
col_q = int(imageurls[pair["p"]["id"]].split("-")[-2])
if "pGroupId" != "1.0" and "qGroupId" != "1.0":
if (kwargs.get("features", 2) != -1) and ((N_dict[imageurls[pair["p"]["id"]]] - col_p < 30) or (N_dict[imageurls[pair["q"]["id"]]] - col_q < 30)):
im_data["features"] = kwargs.get("features", 2)
optflow["images"].append(im_data)
if "features" in im_data:
if im_data["features"] is None:
im_data["features"] = 2
with gzip.GzipFile(cross[:-8]+"_optflow_%d.json.gz" % (count), "w") as fout:
fout.write(json.dumps(optflow, indent=4).encode('utf-8'))
print("Done.")
def upload_resolved_file(render_params, stack, resolved_file, close_stack):
if resolved_file is None:
return
resolved = renderapi.resolvedtiles.ResolvedTiles(
json=jsongz.load(resolved_file))
render = renderapi.connect(**render_params)
renderapi.stack.create_stack(stack, render=render)
renderapi.client.import_tilespecs(stack,
resolved.tilespecs,
sharedTransforms=resolved.transforms,
use_rest=True,
render=render)
if close_stack:
renderapi.stack.set_stack_state(stack, state='COMPLETE', render=render)
logger.info("imported %d tilespecs to render from %s" %
(len(resolved.tilespecs), resolved_file))
url = ("\nhttp://" + "%s:%d" %
(render_params['host'], render_params['port']) +
"/render-ws/view/stacks.html?ndvizHost=em-131fs%3A8001" +
"&renderStack=%s" % stack +
"&renderStackOwner=%s" % render_params['owner'] +
"&renderStackProject=%s" % render_params['project'])
logger.info(url)
return
def make_dbconnection(collection, which='tile'):
if collection['db_interface'] == 'mongo':
if collection['mongo_userName'] != '':
client = MongoClient(
host=collection['mongo_host'],
port=collection['mongo_port'],
username=collection['mongo_userName'],
authSource=collection['mongo_authenticationDatabase'],
password=collection['mongo_password'])
else:
client = MongoClient(
host=collection['mongo_host'],
port=collection['mongo_port'])
if collection['collection_type'] == 'stack':
# for getting shared transforms, which='transform'
mongo_collection_name = (
collection['owner'] +
'__' + collection['project'] +
'__' + collection['name'][0] +
'__'+which)
dbconnection = client.render[mongo_collection_name]
elif collection['collection_type'] == 'pointmatch':
mongo_collection_name = [(
collection['owner'] +
'__' + name) for name in collection['name']]
dbconnection = [
client.match[name] for name in mongo_collection_name]
elif collection['db_interface'] == 'render':
dbconnection = renderapi.connect(**collection)
else:
raise EMalignerException(
"invalid interface in make_dbconnection()")
return dbconnection
def make_dbconnection(collection, which='tile'):
#connect to the database
if collection['db_interface'] == 'mongo':
if collection['mongo_userName'] != '':
#assume authentication
client = MongoClient(
host=collection['mongo_host'],
port=collection['mongo_port'],
username=collection['mongo_userName'],
authSource=collection['mongo_authenticationDatabase'],
password=collection['mongo_password'])
else:
#no authentication
client = MongoClient(host=collection['mongo_host'],
port=collection['mongo_port'])
if collection['collection_type'] == 'stack':
#for getting shared transforms, which='transform'
mongo_collection_name = collection['owner'] + '__' + collection[
'project'] + '__' + collection['name'] + '__' + which
dbconnection = client.render[mongo_collection_name]
elif collection['collection_type'] == 'pointmatch':
mongo_collection_name = collection['owner'] + '__' + collection[
'name']
dbconnection = client.match[mongo_collection_name]
elif collection['db_interface'] == 'render':
dbconnection = renderapi.connect(**collection)
else:
print('invalid interface in make_dbconnection()')
return
return dbconnection
def make_dbconnection(collection, which='tile', interface=None):
"""creates a multi-interface object for stacks and collections
Parameters
----------
collection : :class:`bigfeta.schemas.db_params`
which : str
switch for having mongo retrieve reference transforms
interface : str or None
specification to override bigfeta.schemas.db_params.db_interface
Returns
-------
dbconnection : obj
a multi-interface object used by other functions
in :mod:`bigfeta.utils`
"""
if interface is None:
interface = collection['db_interface']
if interface == 'mongo':
mongoconn = collections.namedtuple('mongoconn', 'client collection')
client = MongoClient(
host=collection['mongo_host'],
port=collection['mongo_port'])
if collection['mongo_userName'] != '':
client = MongoClient(
host=collection['mongo_host'],
port=collection['mongo_port'],
username=collection['mongo_userName'],
authSource=collection['mongo_authenticationDatabase'],
password=collection['mongo_password'])
if collection['collection_type'] == 'stack':
# for getting shared transforms, which='transform'
mongo_collection_name = (
collection['owner'] +
'__' + collection['project'] +
'__' + collection['name'][0] +
'__'+which)
dbconnection = mongoconn(
client=client,
collection=client.render[mongo_collection_name])
elif collection['collection_type'] == 'pointmatch':
mongo_collection_name = [(
collection['owner'] +
'__' + name) for name in collection['name']]
dbconnection = [mongoconn(
client=client,
collection=client.match[name])
for name in mongo_collection_name]
elif interface == 'render':
dbconnection = renderapi.connect(**collection)
elif interface == 'file':
return None
else:
raise BigFetaException(
"invalid interface in make_dbconnection()")
return dbconnection
def run(self):
render = renderapi.connect(**self.args['render'])
tpjson = load_pairjson(self.args['pairJson'], logger=self.logger)
unique_ids, tile_index = parse_tileids(tpjson, logger=self.logger)
tilespecs = load_tilespecs(render, self.args['input_stack'],
unique_ids)
self.match_image_pairs(tilespecs, tile_index)
def test_environment_variables(
rkwargs=rendersettings.DEFAULT_RENDER,
renvkwargs=rendersettings.DEFAULT_RENDER_ENVIRONMENT_VARIABLES,
**kwargs):
def valstostring(d):
return {k: str(v) for k, v in d.items()}
old_env = os.environ.copy()
os.environ.update(valstostring(renvkwargs))
env_render = renderapi.connect(**kwargs)
# restore environment
os.environ.clear()
os.environ.update(old_env)
kwarg_render = renderapi.connect(**dict(valstostring(rkwargs), **kwargs))
assert (valstostring(kwarg_render.DEFAULT_KWARGS) == valstostring(
env_render.DEFAULT_KWARGS) == valstostring(rkwargs))
def upload_collection_file(render_params, collection, collection_file):
if collection is None:
return
render = renderapi.connect(**render_params)
matches = jsongz.load(collection_file)
renderapi.pointmatch.import_matches(collection, matches, render=render)
logger.info("imported %d pointmatches to render from %s" %
(len(matches), collection_file))
def test_renderclientaccess_override(tmpdir):
def checkexpected(expectation, values):
return all([i == j for i, j in zip(expectation, values)])
newargs = dict(args, **{'client_scripts': str(tmpdir)})
assert not os.path.isfile(
renderapi.render.RenderClient.clientscript_from_clientscripts(
str(tmpdir)))
expected = ('newowner', newargs['host'], newargs['port'],
newargs['project'], newargs['client_scripts'],
renderapi.render.RenderClient.clientscript_from_clientscripts(
newargs['client_scripts']))
with open(
renderapi.render.RenderClient.clientscript_from_clientscripts(
str(tmpdir)), 'w') as f: # noqa: F841
# test that renderclientaccess decorated funtion works with Render
# objects missing client_script
assert checkexpected(
expected,
renderclientaccess_decorated(
5, owner='newowner',
render=renderapi.render.Render(**newargs)))
# test that RenderClient objects continue to work
assert checkexpected(
expected,
renderclientaccess_decorated(
5,
owner='newowner',
render=renderapi.render.RenderClient(**newargs)))
# test with renderapi.connect set RenderObjects
assert checkexpected(
expected,
renderclientaccess_decorated(5,
owner='newowner',
render=renderapi.connect(
force_http=False, **newargs)))
os.remove(
renderapi.render.RenderClient.clientscript_from_clientscripts(
str(tmpdir)))
def make_dbconnection(collection, which='tile'):
#connect to the database
if collection['db_interface'] == 'mongo':
client = MongoClient(host=collection['mongo_host'],
port=collection['mongo_port'])
if collection['collection_type'] == 'stack':
#for getting shared transforms, which='transform'
mongo_collection_name = collection['owner'] + '__' + collection[
'project'] + '__' + collection['name'] + '__' + which
dbconnection = client.render[mongo_collection_name]
elif collection['collection_type'] == 'pointmatch':
mongo_collection_name = collection['owner'] + '__' + collection[
'name']
dbconnection = client.match[mongo_collection_name]
elif collection['db_interface'] == 'render':
dbconnection = renderapi.connect(**collection)
else:
print 'invalid interface in make_dbconnection()'
return
return dbconnection
def test_renderclientaccess_decorator_fail(tmpdir):
# test that common methods of defining renderclient options fail quickly
newargs = dict(args, **{'client_scripts': str(tmpdir)})
assert not os.path.isfile(
renderapi.render.RenderClient.clientscript_from_clientscripts(
str(tmpdir)))
with pytest.raises(renderapi.errors.ClientScriptError):
_ = renderclientaccess_decorated(
5, render=renderapi.render.Render(**newargs))
with pytest.raises(renderapi.errors.ClientScriptError):
_ = renderclientaccess_decorated(
5, render=renderapi.render.RenderClient(**newargs)) # noqa: F841
with pytest.raises(renderapi.errors.ClientScriptError):
_ = renderclientaccess_decorated( # noqa: F841
5,
render=renderapi.connect(force_http=False, **newargs))
def render():
render_params['project'] = solver_montage_parameters['input_stack'][
'project']
render = renderapi.connect(**render_params)
return render
def render():
render = renderapi.connect(**render_params)
return render
def render():
render_params['project'] = 'downsample_mask_test'
render = renderapi.connect(**render_params)
return render
def render():
render = renderapi.connect(**rp)
return render
def test_default_kwargs(rkwargs=rendersettings.DEFAULT_RENDER, **kwargs):
r = renderapi.connect(**dict(rkwargs, **kwargs))
new_r = renderapi.connect(**dict(r.DEFAULT_KWARGS, **kwargs))
assert (new_r.DEFAULT_KWARGS == r.DEFAULT_KWARGS == rkwargs)
def render():
render_params['project'] = 'rough_align_test'
render = renderapi.connect(**render_params)
return render
rootdir = os.getcwd()
outputProject = SBEM_test1
outputProject = 'SBEM_test1'
outputOwner = 'SBEM'
outputStack = 'platy_200527'
# make tilespecs
tilespecpaths,mipmap_args = make_tilespec_from_sbemimage(rootdir,outputProject,outputOwner,outputStack)
# generate mipmaps
with renderapi.client.WithPool(8) as pool:
results=pool.map(create_mipmap_from_tuple,mipmap_args)
#connect to render server
render1 = renderapi.connect(host='localhost',port=8080,owner=outputOwner,project=outputProject,client_scripts='/home/schorb/render/render-ws-java-client/src/main/scripts')
#upload metadata to render server
renderapi.client.import_jsonfiles(outputStack,tilespecpaths,render=render1, poolsize=8)
class CreateFastStack(RenderModule):
def __init__(self,schema_type=None,*args,**kwargs):
if schema_type is None:
schema_type = CreateFastStacksParameters
super(CreateFastStack,self).__init__(schema_type=schema_type,*args,**kwargs)
def run(self):
def render():
render_params['project'] = montage_project
render = renderapi.connect(**render_params)
return render
def render():
render_params['project'] = 'multi_correct_test'
render = renderapi.connect(**render_params)
return render
def render():
render_params['project'] = 'swapping_test'
render = renderapi.connect(**render_params)
return render
def run(self):
self.logger.debug('Montage scape stack generation module')
# get the list of z indices
zvalues = self.render.run(renderapi.stack.get_z_values_for_stack,
self.args['montage_stack'])
zvalues1 = self.zValues
zvalues = list(set(zvalues1).intersection(set(zvalues)))
if not zvalues:
raise RenderModuleException(
'No sections found for stack {}'.format(
self.args['montage_stack']))
# generate tuple of old and new Zs
# setting a new z range does not check whether the range
# overlaps with existing sections/chunks in the output stack
if self.args['set_new_z']:
zvalues = list(np.sort(np.array(zvalues)))
diffarray = [x - zvalues[0] for x in zvalues]
newzvalues = [self.args['new_z_start'] + x for x in diffarray]
else:
newzvalues = zvalues
Z = [[int(oldz), int(newz)] for oldz, newz in zip(zvalues, newzvalues)]
out_stack_exists = self.args['output_stack'] in self.render.run(
renderapi.render.get_stacks_by_owner_project)
if out_stack_exists:
# check whether overwrite z is set to false. If so, then remove those z that is already in output stack
outzvalues = renderapi.stack.get_z_values_for_stack(
self.args['output_stack'], render=self.render)
if self.overwrite_zlayer:
# stack has to be in loading state
renderapi.stack.set_stack_state(self.args['output_stack'],
'LOADING',
render=self.render)
for oldz, newz in zip(zvalues, newzvalues):
# delete the section from output stack
renderapi.stack.delete_section(self.args['output_stack'],
newz,
render=self.render)
# generate the tag string to add to output tilespec json file name
tagstr = "%s_%s" % (min(zvalues), max(zvalues))
tilespecdir = os.path.join(self.args['image_directory'],
self.args['render']['project'],
self.args['montage_stack'],
'sections_at_%s' % str(self.args['scale']),
'tilespecs_%s' % tagstr)
try:
os.makedirs(tilespecdir)
except OSError as e:
if e.errno != errno.EEXIST:
raise
pass
render_materialize = renderapi.connect(**self.render.make_kwargs(
memGB=self.args['memGB_materialize']))
# process for each z
mypartial = partial(create_montage_scape_tile_specs,
render_materialize,
self.args['montage_stack'],
self.args['image_directory'],
self.args['scale'],
self.args['render']['project'],
tagstr,
self.args['imgformat'],
apply_scale=self.args['apply_scale'],
level=self.args['level'],
pool_size=1,
doFilter=self.args['doFilter'],
fillWithNoise=self.args['fillWithNoise'],
uuid_prefix=self.args["uuid_prefix"],
uuid_prefix_length=self.args["uuid_length"],
do_mp=False)
with renderapi.client.WithPool(
self.args['pool_size_materialize']) as pool:
pool.map(mypartial, Z)
# get all the output tilespec json files
tspath = os.path.join(self.args['image_directory'],
self.args['render']['project'],
self.args['montage_stack'],
'sections_at_%s' % str(self.args['scale']),
'tilespecs_%s' % tagstr)
jsonfiles = glob.glob("%s/*.json" % tspath)
if not jsonfiles:
raise RenderModuleException(
'No tilespecs json files were generated')
# create the stack if it doesn't exist
if self.output_stack not in self.render.run(
renderapi.render.get_stacks_by_owner_project):
# stack does not exist
# TODO configurable stack metadata
self.render.run(renderapi.stack.create_stack,
self.output_stack,
cycleNumber=5,
cycleStepNumber=1,
stackResolutionX=1,
stackResolutionY=1)
# import tilespecs to render
self.render.run(renderapi.client.import_jsonfiles_parallel,
self.output_stack, jsonfiles)
if self.close_stack:
# set stack state to complete
self.render.run(renderapi.stack.set_stack_state,
self.output_stack,
state='COMPLETE')
self.output({'output_stack': self.output_stack})
def make_plot(self, z1, z2, stack, collection, plot):
cmap = plt.cm.plasma_r
x1, y1, id1 = self.specs(z1, stack)
x2, y2, id2 = self.specs(z2, stack)
dbconnection = make_dbconnection(collection)
# use mongo to get the point matches
stack['db_interface'] = 'render'
render = renderapi.connect(**stack)
iId = self.get_sectionId(stack['name'][0], z1, render)
jId = self.get_sectionId(stack['name'][0], z2, render)
self.pm = get_matches(iId, jId, collection, dbconnection)
print(
'%d tile pairs for z1,z2=%d,%d in collection %s__%s' %
(len(self.pm), z1, z2, collection['owner'], collection['name'][0]))
if not plot:
return
lclist = []
# will hold coordinates of line segments (between tile pairs)
clist = []
# will hold number of point match pairs, used as color
# tiny line to make sure zero is in there for consistent color range
tmp = []
tmp.append((0, 0))
tmp.append((0, 0.1))
lclist.append(tmp)
clist.append(0)
# tiny line to make sure max is in there for consistent color range
tmp = []
tmp.append((0.1, 0.1))
tmp.append((0, 0.1))
lclist.append(tmp)
clist.append(self.args['threshold'])
ntp = 0
if len(self.pm) != 0: # only plot if there are matches
xmin = 1e9
xmax = -1e9
ymin = 1e9
ymax = -1e9
for k in np.arange(len(self.pm)):
# find the tilespecs
k1 = np.argwhere(id1 == self.pm[k]['pId']).flatten()
k2 = np.argwhere(id2 == self.pm[k]['qId']).flatten()
if (k1.size != 0) & (k2.size != 0):
ntp += 1
k1 = k1[0]
k2 = k2[0]
tmp = []
tmp.append((x1[k1], y1[k1]))
tmp.append((x2[k2], y2[k2]))
lclist.append(tmp)
clist.append(len(self.pm[k]['matches']['q'][0]))
for ix in [x1[k1], x2[k2]]:
if ix.min() < xmin:
xmin = ix.min()
if ix.max() > xmax:
xmax = ix.max()
for iy in [y1[k1], y2[k2]]:
if iy.min() < ymin:
ymin = iy.min()
if iy.max() > ymax:
ymax = iy.max()
print('%d tile pairs match stack %s__%s__%s' %
(ntp, stack['owner'], stack['project'], stack['name']))
# plot the line segments all at once for speed:
# https://matplotlib.org/examples/pylab_examples/line_collection2.html
fig = plt.figure(1, figsize=(11.69, 8.27))
fig.clf()
ax = fig.add_subplot(111)
border = 4000
ax.set_xlim(xmin - border, xmax + border)
ax.set_ylim(ymin - border, ymax + border)
LC = LineCollection(lclist, cmap=cmap)
LC.set_array(np.array(clist))
ax.add_collection(LC)
fig = plt.gcf()
ax.set_aspect('equal')
ax.patch.set_color([0.5, 0.5, 0.5])
ax.set_title('%s %s\n%d tile pairs %d point pairs' %
(z1, z2, len(self.pm), sum(clist[2:])))
ax.invert_yaxis()
fig.colorbar(LC)
plt.draw()
fname = '%s/%s_%d_%d.pdf' % (self.args['plot_dir'],
collection['name'], z1, z2)
pdf = PdfPages(fname)
pdf.savefig(fig) # save the figure as a pdf page
pdf.close()
plt.ion()
plt.show()
print('wrote %s' % fname)
self.outputname = fname
def render():
render_params['project'] = 'rough_registration'
render = renderapi.connect(**render_params)
return render
import renderapi
from synapsedb import db
from synapsedb.volumes.models import DataSet, Volume, ImageChannel
owner = "Forrest"
project = "M247514_Rorb_1"
script_loc = "/Users/forrestc/RenderStack/render/render-ws-java-client/src/main/scripts/" # noQA: E501
render_params = {
"host": "ibs-forrestc-ux1.corp.alleninstitute.org",
"port": "80",
"owner": owner,
"project": project,
"client_scripts": script_loc
}
render = renderapi.connect(**render_params)
channels = ImageChannel.query.all()
volumes = Volume.query.all()
datasets = DataSet.query.all()
for obj in channels + volumes + datasets:
db.session.delete(obj)
ds = DataSet(name=project, render_owner=owner, render_project=project)
db.session.add(ds)
volume = Volume(name="BIG ALIGN LENS", dataset=ds)
db.session.add(volume)
mult_chan_stacks = [
"BIGALIGN_LENS_Session1", "BIGALIGN_LENS_Session2",
"BIGALIGN_LENS_Session3"
def render():
render_params['project'] = 'point_match_optimization'
render = renderapi.connect(**render_params)
return render
