def visualize(dataset, split, aff, ip, port): """ Opens a tab in your webbrowser showing the chosen dataset """ import neuroglancer config = config_dict(dataset) neuroglancer.set_static_content_source( url='https://neuroglancer-demo.appspot.com') neuroglancer.set_server_bind_address(bind_address=ip, bind_port=port) viewer = neuroglancer.Viewer(voxel_size=[6, 6, 30]) if aff: import augmentation augmentation.maybe_create_affinities(split) add_affinities(config.folder, split + '-affinities', viewer) else: add_file(config.folder, split + '-input', viewer) add_file(config.folder, split + '-labels', viewer) print('open your brower at:') print(viewer.__str__().replace('172.17.0.2', '54.166.106.209') ) # Replace the second argument with your own server's ip address webbrowser.open(viewer.__str__()) print("press any key to exit") input()
def __call__(self, chunks: dict): """ Parameters: chunks: multiple chunks """ ng.set_static_content_source( url='https://neuromancer-seung-import.appspot.com') ng.set_server_bind_address(bind_port=self.port) viewer = ng.Viewer() with viewer.txn() as s: for chunk_name, chunk in chunks.items(): global_offset = chunk.global_offset chunk = np.ascontiguousarray(chunk) s.layers.append( name=chunk_name, layer=ng.LocalVolume( data=chunk, dimensions=neuroglancer.CordinateSpace( scales=[1, *self.voxel_size[::-1]], units=['', 'nm', 'nm', 'nm'], names=['c^', 'x', 'y', 'z']), # offset is in nm, not voxels offset=list(o * v for o, v in zip( global_offset[::-1][-3:], self.voxel_size[::-1])))) print('Open this url in browser: ') print(viewer) input('Press Enter to exit neuroglancer.')
def main(): logging.basicConfig(level=logging.INFO) args = parse_args() if args.ip_address is not None and args.port is not None: neuroglancer.set_server_bind_address(bind_address=args.ip_address, bind_port=args.port) elif args.ip_address is not None: neuroglancer.set_server_bind_address(bind_address=args.ip_address) elif args.port is not None: neuroglancer.set_server_bind_address(bind_port=args.port) if args.static_content_source is not None: neuroglancer.set_static_content_source(url=args.static_content_source) reference_voxel_size = \ [float(_)*1000 for _ in args.reference_voxel_size.split(",")] moving_voxel_size = \ [float(_)*1000 for _ in args.moving_voxel_size.split(",")] logging.info("Reading reference image") reference_image = tifffile.imread(args.reference_image).astype(np.float32) logging.info("Reading moving image") moving_image = tifffile.imread(args.moving_image).astype(np.float32) if args.segmentation is not None: logging.info("Reading segmentation") segmentation = tifffile.imread(args.segmentation).astype(np.uint32) else: segmentation = None vp = ViewerPair(reference_image, moving_image, segmentation, args.points, reference_voxel_size, moving_voxel_size) if not args.no_launch: vp.launch_viewers() vp.print_viewers() while True: time.sleep(10)
def main(args=sys.argv[1:]): opts = parse_args(args) neuroglancer.set_static_content_source(url=opts.static_content_source) neuroglancer.set_server_bind_address(opts.bind_address, opts.port) viewer_pair = ViewerPair(opts.fixed_url, opts.moving_url, opts.filtered_pts) while True: time.sleep(10)
def run_vol(vol_idx): neuroglancer.set_static_content_source(url='https://neuroglancer-demo.appspot.com') with h5py.File(os.path.expanduser('~/data/div_detect/full_records.h5'), 'r') as rec_file: record = rec_file['records'][vol_idx,:, :, :, 1] viewer = neuroglancer.Viewer(voxel_size=[1, 1, 1]) viewer.add(vol_to_int8(record), name='record') #viewer.add(b, name='b') return viewer
def main(): app = QtWidgets.QApplication(sys.argv) args = parse_args() if args.static_content_source is not None: neuroglancer.set_static_content_source( url=args.static_content_source) neuroglancer.set_server_bind_address( args.bind_address, bind_port=args.port) viewer = neuroglancer.Viewer() print("Neuroglancer URL: %s" % str(viewer)) window = ApplicationWindow(viewer) window.show() sys.exit(app.exec())
def __init__(self): # Address neuroglancer.set_server_bind_address('127.0.0.1') neuroglancer.set_static_content_source(url='http://localhost:8080') # Data img = tifffile.imread('sample.tif') img = img * 10 / 256 img = img.astype('uint8') img = np.transpose(img, (1, 0, 2, 3)) self.img = img # Same viewer every function call viewer = self.viewer = neuroglancer.Viewer()
def create_neuroglancer_viewer(model:Model) -> neuroglancer.Viewer: """ Create a viewer for a Neuroglancer instance :param model: has the details for the static Neuroglancer elements :return: a Neuroglancer viewer that can be used to display volumes """ if not model.neuroglancer_initialized.get(): neuroglancer.set_static_content_source( url=model.static_content_source.get()) neuroglancer.set_server_bind_address( model.bind_address.get(), model.port_number.get()) model.neuroglancer_initialized.set(True) return neuroglancer.Viewer()
def run_interactive(args, graph): # Make splitter a global variable so that it is accessible from the # interactive `python -i` shell. global splitter if args.bind_address: neuroglancer.set_server_bind_address(args.bind_address) if args.static_content_url: neuroglancer.set_static_content_source(url=args.static_content_url) splitter = InteractiveSplitter(graph, agglo_id=args.agglo_id, image_url=args.image_url, segmentation_url=args.segmentation_url, state_path=args.state) print(splitter.viewer)
def main(): parser = argparse.ArgumentParser() parser.add_argument("files_and_colors", nargs="+", help="File name followed by display name followed by" "\"red\", \"green\", \"blue\" or \"gray\".") parser.add_argument("--segmentation", default=None, help="Segmentation volume to display") parser.add_argument("--ip-address", default="127.0.0.1", help="IP address of neuroglancer server.") parser.add_argument("--port", default=0, type=int, help="Port # of neuroglancer server.") parser.add_argument("--static-content-source", default=None, help="The URL of the static content source, e.g. " "http://localhost:8080 if being served via npm.") args = parser.parse_args() if args.static_content_source is not None: neuroglancer.set_static_content_source(url=args.static_content_source) neuroglancer.set_server_bind_address(args.ip_address, args.port) viewer = neuroglancer.Viewer() with viewer.txn() as txn: for filename, name, colorname in zip(args.files_and_colors[::3], args.files_and_colors[1::3], args.files_and_colors[2::3]): img = tifffile.imread(filename).astype(np.float32) if colorname.lower() == "red": shader = red_shader elif colorname.lower() == "green": shader = green_shader elif colorname.lower() == "blue": shader = blue_shader else: shader = gray_shader layer(txn, name, img, shader, 1.0) if args.segmentation != None: seg = tifffile.imread(args.segmentation).astype(np.uint32) seglayer(txn, "segmentation", seg) print(viewer.get_viewer_url()) webbrowser.open(viewer.get_viewer_url()) while True: time.sleep(5)
def run_interactive(args, graph): # Make splitter a global variable so that it is accessible from the # interactive `python -i` shell. global splitter if args.bind_address: neuroglancer.set_server_bind_address(args.bind_address) if args.static_content_url: neuroglancer.set_static_content_source(url=args.static_content_url) splitter = InteractiveSplitter( graph, agglo_id=args.agglo_id, image_url=args.image_url, segmentation_url=args.segmentation_url, state_path=args.state) print(splitter.viewer)
def main(): global output_file_name global synapses global viewer args = parse_args() neuroglancer.set_static_content_source(url=args.static_content_source) neuroglancer.set_server_bind_address(bind_port=int(args.port)) image_url = args.image_url segmentation_url = args.segmentation_url output_file_name = args.output synapse_dict = json.load(open(args.synapses)) for n1, n2, x, y, z in zip(synapse_dict["neuron_1"], synapse_dict["neuron_2"], synapse_dict["synapse_center"]["x"], synapse_dict["synapse_center"]["y"], synapse_dict["synapse_center"]["z"]): synapses.append(Synapse(n1, n2, x, y, z)) viewer = neuroglancer.Viewer() with viewer.txn() as s: s.layers['image'] = neuroglancer.ImageLayer(source=image_url) s.layers['segmentation'] = neuroglancer.SegmentationLayer( source=segmentation_url) viewer.actions.add("yes", lambda _: yes()) viewer.actions.add("no", lambda _: no()) viewer.actions.add("skip", lambda _: skip()) viewer.actions.add("back", lambda _: back()) viewer.actions.add("revert", lambda _: set_viewer_state()) with viewer.config_state.txn() as s: s.input_event_bindings.viewer['shift+keyy'] = 'yes' s.input_event_bindings.viewer["shift+keyn"] = "no" s.input_event_bindings.viewer["shift+keys"] = "skip" s.input_event_bindings.viewer["shift+keyr"] = "revert" s.input_event_bindings.viewer["shift+keyb"] = "back" set_viewer_state() webbrowser.open_new(viewer.get_viewer_url()) while True: time.sleep(1)
import neuroglancer ap = argparse.ArgumentParser() ap.add_argument( '-a', '--bind-address', help='Bind address for Python web server. Use 127.0.0.1 (the default) to restrict access ' 'to browers running on the local machine, use 0.0.0.0 to permit access from remote browsers.') ap.add_argument( '--static-content-url', help='Obtain the Neuroglancer client code from the specified URL.') args = ap.parse_args() if args.bind_address: neuroglancer.set_server_bind_address(args.bind_address) if args.static_content_url: neuroglancer.set_static_content_source(url=args.static_content_url) a = np.zeros((3, 100, 100, 100), dtype=np.uint8) ix, iy, iz = np.meshgrid(* [np.linspace(0, 1, n) for n in a.shape[1:]], indexing='ij') a[0, :, :, :] = np.abs(np.sin(4 * (ix + iy))) * 255 a[1, :, :, :] = np.abs(np.sin(4 * (iy + iz))) * 255 a[2, :, :, :] = np.abs(np.sin(4 * (ix + iz))) * 255 b = np.cast[np.uint32](np.floor(np.sqrt((ix - 0.5)**2 + (iy - 0.5)**2 + (iz - 0.5)**2) * 10)) b = np.pad(b, 1, 'constant') viewer = neuroglancer.Viewer() with viewer.txn() as s: s.voxel_size = [10, 10, 10] s.layers.append( name='a',
ix, iy, iz = np.meshgrid(*[np.linspace(0, 1, n) for n in a.shape[1:]], indexing='ij') a[0, :, :, :] = np.abs(np.sin(4 * (ix + iy))) * 255 a[1, :, :, :] = np.abs(np.sin(4 * (iy + iz))) * 255 a[2, :, :, :] = np.abs(np.sin(4 * (ix + iz))) * 255 b = np.cast[np.uint32](np.floor( np.sqrt((ix - 0.5)**2 + (iy - 0.5)**2 + (iz - 0.5)**2) * 10)) # Obtain the bundled Neuroglancer client code (HTML, CSS, and JavaScript) from # the demo server, so that this example works even if # # python setup.py bundle_client # # has not been run. neuroglancer.set_static_content_source( url='https://neuroglancer-demo.appspot.com') viewer = neuroglancer.Viewer() viewer.add(a, name='a', offset=(20, 30, 50), shader=""" void main() { emitRGB(vec3(toNormalized(getDataValue(0)), toNormalized(getDataValue(1)), toNormalized(getDataValue(2)))); } """) viewer.add(b, name='b') print(viewer)
#!/usr/bin/env python2 """Tool for extending via equivalences a set of segments.""" from __future__ import absolute_imports, print_function import argparse import copy import os import webbrowser import neuroglancer from neuroglancer.json_utils import decode_json, encode_json neuroglancer.set_static_content_source(url='http://localhost:8080') def get_segmentation_layer(layers): for layer in layers: if isinstance(layer.user_layer, neuroglancer.SegmentationLayer): return layer class Annotator(object): def __init__(self, filename): self.filename = filename self.point_annotation_layer_name = 'false-merges' self.states = [] self.state_index = None viewer = self.viewer = neuroglancer.managed_viewer.ManagedViewer() self.other_state_segment_ids = dict()
def main(): app = QtWidgets.QApplication(sys.argv) args = parse_args() patches_xy, patches_xz, patches_yz = [[] for _ in range(3)] for i, patch_file in enumerate(args.patch_file): with h5py.File(patch_file, "r") as fd: if len(patches_xy) > 0: if len(fd["x"]) != len(x) or \ not np.all(fd["x"][:] == x) or\ not np.all(fd["y"][:] == y) or\ not np.all(fd["z"][:] == z): raise ValueError("The patch files need to be constructed " "using the same set of blob coordinates") if fd["patches_xy"].shape != patches_xy[0].shape: raise ValueError("Patch sizes need to be the same") else: x = fd["x"][:] y = fd["y"][:] z = fd["z"][:] patches_xy.append(fd["patches_xy"][:]) patches_xz.append(fd["patches_xz"][:]) patches_yz.append(fd["patches_yz"][:]) if args.neuroglancer is None or len(args.neuroglancer) == 0: viewer = None image_names = None multiplier = None colors = [] else: import neuroglancer import webbrowser if args.static_content_source is not None: neuroglancer.set_static_content_source( url=args.static_content_source) neuroglancer.set_server_bind_address(args.bind_address, bind_port=args.port) viewer = neuroglancer.Viewer() print("Neuroglancer URL: %s" % str(viewer)) image_names = args.image_name or [] while len(image_names) < len(args.neuroglancer): image_names.append("image_%d" % (len(image_names) + 1)) colors = args.color or [] ckeys = list(COLORS.keys()) while len(colors) < len(args.neuroglancer): for color in ckeys: if color not in colors: colors.append(color) break else: colors.append(ckeys[len(colors) % len(COLORS)]) multiplier = args.multiplier or [] while len(multiplier) < len(args.neuroglancer): multiplier.append(1.0) with viewer.txn() as txn: for i in range(len(args.neuroglancer)): txn.layers[image_names[i]] = neuroglancer.ImageLayer( source=args.neuroglancer[i], shader=COLORS[colors[i]] % multiplier[i]) webbrowser.open_new(viewer.get_viewer_url()) window = ApplicationWindow(patches_xy, patches_xz, patches_yz, x, y, z, args.n_components, args.use_position, args.whiten, args.max_samples, args.n_jobs, args.output, viewer, image_names, multiplier, [COLORS[_] for _ in colors]) window.setWindowTitle("Train") window.show() sys.exit(app.exec())
def main(): global viewer parser = argparse.ArgumentParser(description="NeUroGlancer Ground Truth") parser.add_argument("--port", type=int, help="HTTP port for server", default=0) parser.add_argument("--image", help="Path to image file", required=True) parser.add_argument("--alt-image", help="Path to a second image channel") parser.add_argument("--output", help="Path to list of point annotations", required=True) parser.add_argument("--detected", help="Path to list of detected point annotations", required=False) parser.add_argument("--min-distance", help="Minimum distance between two annotations", type=int, default=10) parser.add_argument("--segmentation", help="Path to existing segmentation file (optional)") parser.add_argument("--coordinates", help="Coordinates of the image volume to edit" "(x0,x1,y0,y1,z0,z1). " "Example: \"1000,2000,4000,5000,300,500\" to edit" "x=1000 to 2000, y=4000 to 5000, z=300 to 500.") parser.add_argument("--box-coordinates", help="Coordinates of the bounding box to display. " "Example: \"1000,2000,4000,5000,300,500\" to edit " "x=1000 to 2000, y=4000 to 5000, z=300 to 500", default=None) parser.add_argument("--bind-address", help="The IP address to bind to as a webserver. " "The default is 127.0.0.1 which is constrained to " "the local machine.", default="127.0.0.1") parser.add_argument("--static-content-source", default=None, help="The URL of the static content source, e.g. " "http://localhost:8080 if being served via npm.") parser.add_argument("--reference-image", help="An image of a reference volume to be used " "for navigation.") parser.add_argument("--reference-segmentation", help="A segmentation image of the reference volume " "to be used for navigation.") parser.add_argument("--reference-points", help="The point annotations, transformed into the " "reference space.") parser.add_argument("--point-correspondence-file", help="A .json file containing arrays of moving " "and reference points to be used to warp the reference" " frame into the moving frame.") parser.add_argument("--repositioning-log-file", default=None, help="This file saves a record of the coordinates " "of each repositioning in order to keep track of " "which areas have been visited.") parser.add_argument("--multiplier", default=1.0, type=float, help="Multiplier for the image. Higher = brighter.") parser.add_argument("--alt-multiplier", default=1.0, type=float, help="Multiplier for the alternate image. " "Higher=brighter") args = parser.parse_args() neuroglancer.set_server_bind_address(args.bind_address, bind_port=args.port) if args.box_coordinates is None: box_coordinates = None else: box_coordinates = list(map(int, args.box_coordinates.split(","))) box_coordinates = [box_coordinates[::2], box_coordinates[1::2]] if args.static_content_source is not None: neuroglancer.set_static_content_source(url=args.static_content_source) if args.coordinates: x0, x1, y0, y1, z0, z1 = list(map(int, args.coordinates.split(","))) viewer = NuggtViewer(args.image, args.alt_image, args.segmentation, args.output, args.detected, x0, x1, y0, y1, z0, z1, min_distance=args.min_distance, multiplier=args.multiplier, alt_multiplier=args.alt_multiplier, box_coords=box_coordinates) else: viewer = NuggtViewer(args.image, args.alt_image, args.segmentation, args.output, args.detected, min_distance=args.min_distance, multiplier=args.multiplier, alt_multiplier=args.alt_multiplier, box_coords=box_coordinates) print("Editing viewer: %s" % viewer.viewer.get_viewer_url()) webbrowser.open_new(viewer.viewer.get_viewer_url()) if args.reference_image is not None: ref_img = tifffile.imread(args.reference_image).astype(np.float32) ref_seg = tifffile.imread(args.reference_segmentation).astype( np.uint16) with open(args.point_correspondence_file) as fd: d = json.load(fd) moving = np.array(d["moving"]) reference = np.array(d["reference"]) nav_viewer = NavViewer(ref_img, ref_seg, moving, reference, viewer.shape) nav_viewer.bind() if args.repositioning_log_file is not None: nav_viewer.repositioning_log_file = args.repositioning_log_file sample = np.random.permutation(len(viewer.points))[:10000] if args.reference_points is not None: with open(args.reference_points) as fd: rp = np.array(json.load(fd)) pts = rp[sample, ::-1] else: pts = viewer.points[sample, ::-1] nav_viewer.add_points(pts) print("Navigating viewer: %s" % nav_viewer.viewer.get_viewer_url()) print("Hit control-c to exit") while True: time.sleep(10)
#!/usr/bin/env python2 """Tool for extending via equivalences a set of segments.""" from __future__ import absolute_import, print_function import argparse import copy import os import webbrowser import neuroglancer from neuroglancer.json_utils import decode_json, encode_json neuroglancer.set_static_content_source(url='http://localhost:8080') def get_segmentation_layer(layers): for layer in layers: if isinstance(layer.layer, neuroglancer.SegmentationLayer): return layer class Annotator(object): def __init__(self, filename): self.filename = filename self.point_annotation_layer_name = 'false-merges' self.states = [] self.state_index = None viewer = self.viewer = neuroglancer.Viewer() self.other_state_segment_ids = dict()
a = np.zeros((3, 100, 100, 100), dtype=np.uint8) ix, iy, iz = np.meshgrid(*[np.linspace(0, 1, n) for n in a.shape[1:]], indexing='ij') a[0, :, :, :] = np.abs(np.sin(4 * (ix + iy))) * 255 a[1, :, :, :] = np.abs(np.sin(4 * (iy + iz))) * 255 a[2, :, :, :] = np.abs(np.sin(4 * (ix + iz))) * 255 b = np.cast[np.uint32](np.floor(np.sqrt((ix - 0.5)**2 + (iy - 0.5)**2 + (iz - 0.5)**2) * 10)) b = np.pad(b, 1, 'constant') # Obtain the bundled Neuroglancer client code (HTML, CSS, and JavaScript) from # the demo server, so that this example works even if # # python setup.py bundle_client # # has not been run. neuroglancer.set_static_content_source(url='https://neuroglancer-demo.appspot.com') viewer = neuroglancer.Viewer(voxel_size=[10, 10, 10]) viewer.add(a, name='a', # offset is in nm, not voxels offset=(200, 300, 150), shader=""" void main() { emitRGB(vec3(toNormalized(getDataValue(0)), toNormalized(getDataValue(1)), toNormalized(getDataValue(2)))); } """) viewer.add(b, name='b') print(viewer)
raw_input("press enter to continue") commit(cutout) raw_input("press enter to continue") load(cutout.pos) current_index = 0 def next_index(jump=1): global current_index current_index = current_index + jump return current_index neuroglancer.set_static_content_source( url='http://seung-titan02.pni.princeton.edu:8080') #basename = sys.argv[1] basename = os.path.expanduser("~/mydatasets/3_3_1/") print("loading files...") vertices = h5read(os.path.join(basename, "vertices.h5"), force=True) edges = h5read(os.path.join(basename, "epoch1_edges.h5"), force=True) V = Volume( basename, { "image": "image.h5", "errors": "epoch1_errors.h5", "raw_labels": "raw.h5", "affinities": "aff.h5", "valid_list": "valid.h5",
#! /bin/env python ## basic shim to load up neuroglancer in a browser: import neuroglancer import logging from time import sleep import progproxy as pp import redis logging.basicConfig(level=logging.DEBUG) # we are currently using the seunglab hosted neuroglancer static resources # ideally this would be self hosted for local development against nglancer logging.info("configuring neuroglancer defaults") neuroglancer.set_static_content_source( url="https://neuromancer-seung-import.appspot.com") ## neuroglancer setup segment: ## set the tornado server that is launched to talk on all ips and at port 8080 neuroglancer.set_server_bind_address("0.0.0.0", "8080") neuroglancer.debug = True neuroglancer.server.debug = True logging.info("starting viewer subprocess") # setup a viewer with pre-configured defaults and launch. viewer = neuroglancer.Viewer() logging.info("viewer token: {}".format(viewer.token)) logging.info("setting viewers default volume") # load data from cloudvolume container: with viewer.txn() as s:
###WINDOW 2### #to add another layer (aka the atlas), in a new ipython window: from cloudvolume import CloudVolume brainname = "20200701_12_55_28_20170207_db_bl6_crii_rpv_01" port = 1350 layer_dir = "/jukebox/scratch/zmd/save/contra_ipsi_projection_studies_20191125/%s/atlas" % brainname vol = CloudVolume(f"file://{layer_dir}") vol.viewer(port=port + 1) #make sure this port is different from the first ###WINDOW 3### #in another ipython window run: import neuroglancer neuroglancer.set_static_content_source( url="https://nglancer.pni.princeton.edu") brainname = "20200701_12_55_28_20170207_db_bl6_crii_rpv_01" port = 1350 viewer = neuroglancer.Viewer() with viewer.txn() as s: s.layers["%s" % brainname] = neuroglancer.ImageLayer( source="precomputed://http://localhost:%s" % port) print(viewer) #this should add the above volume to the neuroglancer window with viewer.txn() as s: s.layers["%s_atlas" % brainname] = neuroglancer.SegmentationLayer( source="precomputed://http://localhost:%s" % int(port + 1)) print(viewer) #this should add the atlas volume to the neuroglancer window
def main(): parser = argparse.ArgumentParser() parser.add_argument("--bind-address", help="The IP address to bind to as a webserver. " "The default is 127.0.0.1 which is constrained to " "the local machine.", default="127.0.0.1") parser.add_argument("--port", type=int, help="HTTP port for server", default=0) parser.add_argument("--gray-image", help="Path to an image file to be displayed in gray.") parser.add_argument("--gray-image-name", help="The name of the gray image", default="image") parser.add_argument("--red-image", help="Path to an image file to be displayed in red.") parser.add_argument("--red-image-name", help="The name of the red image", default="red") parser.add_argument("--green-image", help="Path to an image file to be displayed in green.") parser.add_argument("--green-image-name", help="The name of the green image", default="green") parser.add_argument("--blue-image", help="Path to an image file to be displayed in blue.") parser.add_argument("--blue-image-name", help="The name of the blue image", default="blue") parser.add_argument("--input-coordinates", help="A JSON file of input coordinates as a list of " "three-tuples in X, Y, Z order", required=True) parser.add_argument("--yea-coordinates", help="The name of a JSON file to be written with " "the coordinates of \"yea\" points.") parser.add_argument("--nay-coordinates", help="The name of a JSON file to be written with the " "coordinates of \"nay\" points.") parser.add_argument("--no-browser", help="Do not launch the browser", action="store_true") parser.add_argument("--new-browser-window", help="Open Neuroglancer in a new browser window.", action="store_true") parser.add_argument("--static-content-source", default=None, help="The URL of the static content source, e.g. " "http://localhost:8080 if being served via npm.") args = parser.parse_args() if args.static_content_source != None: neuroglancer.set_static_content_source(url=args.static_content_source) neuroglancer.set_server_bind_address(args.bind_address, bind_port=args.port) with open(args.input_coordinates) as fd: points = np.array(json.load(fd)) imgs = [] for path, name, shader in ((args.gray_image, args.gray_image_name, gray_shader), (args.red_image, args.red_image_name, red_shader), (args.green_image, args.green_image_name, green_shader), (args.blue_image, args.blue_image_name, blue_shader)): if path is not None: img = tifffile.imread(path) imgs.append((img, name, shader)) def save_cb(yea, nay): if args.yea_coordinates is not None: yea = yea.astype(points.dtype) with open(args.yea_coordinates, "w") as fd: json.dump(yea.tolist(), fd) if args.nay_coordinates is not None: nay = nay.astype(points.dtype) with open(args.nay_coordinates, "w") as fd: json.dump(nay.tolist(), fd) if args.no_browser: yea, nay = sort_points(imgs, points, save_cb=save_cb) elif args.new_browser_window: yea, nay = sort_points(imgs, points, launch_ui="new", save_cb=save_cb) else: yea, nay = sort_points(imgs, points, launch_ui=True, save_cb=save_cb) save_cb(yea, nay)
def main(): parser = argparse.ArgumentParser() parser.add_argument("files_and_colors", nargs="+", help="File name followed by display name followed by" "\"red\", \"green\", \"blue\", \"gray\", " "\"jet\" or \"cubehelix\".") parser.add_argument("--segmentation", default=None, help="Segmentation volume to display") parser.add_argument("--ip-address", default="127.0.0.1", help="IP address of neuroglancer server.") parser.add_argument("--port", default=0, type=int, help="Port # of neuroglancer server.") parser.add_argument("--static-content-source", default=None, help="The URL of the static content source, e.g. " "http://localhost:8080 if being served via npm.") parser.add_argument("--points", help="A points file in X, Y, Z order to display") parser.add_argument("--show-n", type=int, help="Show only a certain number of randomly selected " "points.") args = parser.parse_args() if args.static_content_source is not None: neuroglancer.set_static_content_source(url=args.static_content_source) neuroglancer.set_server_bind_address(args.ip_address, args.port) viewer = neuroglancer.Viewer() with viewer.txn() as txn: for filename, name, colorname in zip(args.files_and_colors[::3], args.files_and_colors[1::3], args.files_and_colors[2::3]): if colorname.lower() == "red": shader = red_shader elif colorname.lower() == "green": shader = green_shader elif colorname.lower() == "blue": shader = blue_shader elif colorname.lower() in ("gray", "grey"): shader = gray_shader elif colorname.lower() == "jet": shader = jet_shader else: shader = cubehelix_shader if filename.startswith("precomputed://"): txn.layers[name] = neuroglancer.ImageLayer( source = filename, shader = shader % 1.0 ) continue paths = sorted(glob.glob(filename)) if len(paths) == 0: sys.stderr.write("Could not find any files named %s" % filename) exit(1) elif len(paths) == 1: img = tifffile.imread(paths[0]).astype(np.float32) else: img = np.array([tifffile.imread(_) for _ in paths], np.float32) layer(txn, name, img, shader, 1.0) if args.segmentation != None: seg = tifffile.imread(args.segmentation).astype(np.uint32) seglayer(txn, "segmentation", seg) if args.points is not None: with open(args.points) as fd: points = np.array(json.load(fd)) if args.show_n is not None: points = points[np.random.choice(len(points), args.show_n)] pointlayer(txn, "points", points[:, 0], points[:, 1], points[:, 2], "red") print(viewer.get_viewer_url()) webbrowser.open(viewer.get_viewer_url()) while True: time.sleep(5)
def set_neuroglancer_static_source(url): neuroglancer.set_static_content_source(url=url)
units='nm', scales=[10, 10, 10], ) with viewer.txn() as s: s.layers.append( name='a', layer=neuroglancer.SegmentationLayer( source=[ neuroglancer.LocalVolume( data=segmentation, dimensions=dimensions, ), SkeletonSource(dimensions), ], skeleton_shader='void main() { emitRGB(colormapJet(affinity)); }', selected_alpha=0, not_selected_alpha=0, )) if __name__ == '__main__': ap = argparse.ArgumentParser() ap.add_argument('--static-content-url') ap.add_argument('-a', '--bind-address') args = ap.parse_args() neuroglancer.server.debug = True if args.bind_address: neuroglancer.set_server_bind_address(args.bind_address) if args.static_content_url: neuroglancer.set_static_content_source(url=args.static_content_url) print(viewer)
logging.info("configuring neuroglancer defaults") task = subprocess.Popen("ip route | awk 'NR==1 {print $3}'",shell=True,stdout=subprocess.PIPE) data = task.stdout.read() localhost_addr = data.decode('utf-8').strip('\n') logging.debug("Got localhost address inside container:") logging.debug(localhost_addr) # response = requests.get(f'http://nglancerstatic:8080') response = requests.get(f'http://{localhost_addr}:8080') logging.debug("Response from neuroglancer container is:") logging.debug(response) logging.debug(response.text) # neuroglancer.set_static_content_source( # url="https://neuromancer-seung-import.appspot.com" # ) neuroglancer.set_static_content_source( url=f"http://{localhost_addr}:8080" ) ## neuroglancer setup segment: ## set the tornado server that is launched to talk on all ips and at port 8080 neuroglancer.set_server_bind_address("0.0.0.0", "8081") neuroglancer.debug = True neuroglancer.server.debug = True logging.info("starting viewer subprocess") # setup a viewer with pre-configured defaults and launch. viewer = neuroglancer.Viewer() # sleep(0.5) logging.info("viewer token: {}".format(viewer.token)) logging.info("setting viewers default volume")