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