-
Notifications
You must be signed in to change notification settings - Fork 3
Milestones
List view
In some ways this is the final milestone and the ultimate goal of STS. We need to produce a functional wiring diagram. In order to do so we may not be so interested in the spatial data, and thus we simply want to convert the segmented voxel map into an abstract list of connections. Each neuron will be reduced down to a neuron object, which will be a graph data structure with any number of inputs and any number of outputs. We may want to use an interface for this (I believe), as NES will ultimately implement the logic of each neuron. STS simply produces a wiring diagram of the relevant types, that must then be filled in. However, the exact implementation the abstracted connectome takes will depend on the requirements (which we must get from a neuroscience consultant). Ultimately, we want to ensure we retain all relevant data; spatial data can be abtracted away but only if we've first extracted all the relevant information (for example, if we need to take into account the flow of chemicals in the cerebrospinal fluid (which we likely do), then we may need to retain more information than just what's connected to what; this could be as simple as a global modifier, but more likely this is a localized problem).
No due dateNow that we can produce a 3D voxel map, it's time to start segmenting this into discrete neurons. In order to do this we'll require a computer vision system that can work with 3D voxel maps. The computer vision system will request a region of interest from the 3D voxel map producer, and from this it will produce a second 3D voxel map which will be the segmented voxel map. Each segment will have its own unique ID associated to it such that we can address each segment produced by the system (i.e., we can hide all but one neuron, for example). At this stage we effectively have a connectome, but it isn't abstract enough, nor does it carry information on the individual neurons or synapses (the only information we have is spatial information; we know where things are located and what they look like, and perhaps what class they fall into (neuron (neuron type), synapse, etc)). This stage will again, take a region of interest from some caller and will produce results at this region of interest.
No due dateNext we want to stack the layers so that we can produce a 3D voxel map (each pixel becomes a voxel). Previous milestones should have ensured each layer is already in the correct order, so all we have to do is ensure each layer is properly aligned. We may be able to use the delta of each layer to achieve this (i.e., figure out how different features are between layers, and align layers such that the most similar layers are above each other (thus minimizing the global difference delta between two layers)). After this is done, the layers are now stacked and we can produce a 3D voxel map when a 3D region is requested. So what this means is basically, we won't store this 3D voxel map on disk or in memory, but we will initially align the layers and then once we know the layers are aligned, going forward we will simply ask the previous milestone for the relevant regions of the relevant layers. We then stack these and produce a 3D voxel map of the region of interest, which we then give to whoever requested it.
No due dateThe next stage of abstraction is to begin stitching adjacent images. The previous milestone calls for the grouping of adjacent images into layers. Now that we have layers (with every discrete image in the correct location within the 2D array) we can begin stitching images together into one large image. This may not be as easy as simply making one big array, as some data may overlap. In the event of data overlap, it might be as easy as checking if the adjacent edges of one image are equal to the adjacent edges of its neighbours (in which case we simply keep the first image's edges and cut the duplicated section from the neighbour, before combining them into one image). The ultimate output of this stage is each layer as a single image. Each image must be the same size and resolution, so we must first find the largest image (if one layer happens to be larger than the rest and doesn't already have padding) and then add padding to make each layer the same size (i.e., add a bunch of 0s to the array in such a way we don't shift the alignment). However, we may not be able to store images of this size in memory or on disk (it may be terrabytes per layer), so we'll need to keep things tiled, but have a data loading object that produces this continuous image for the region of interest. So for example, when the computer vision system starts looking at images, it isn't responsible for loading and stitching but rather, it asks for a coordinate range and recieves the appropriate image for that range.
No due dateWe need to be able to load each image in the dataset in the correct sequence. While we may be unable to store the entire dataset in memory, we need to at least understand its structure so that we can begin to work with it. This will be the first step in data abstraction; we want to make it easier to work with this data, so we need a system that will load it from disk in the correct order as we access it, grouping adjacent images into layers (but not stitching them yet, that's the next abstraction stage).
No due dateThe TEMCA2 dataset will likely do. However, we need a large amount of storage space for this, and we need to make it accessible to our members without having to download the entire thing to their local devices. Ideally we should download it to a server we own, and then make the data accessible through a RESTful API or some other such easy to use API. I believe TEMCA2 (or related projects) may already have an API, in which case we should explore that, and perhaps look into mirroring it. Ideally we would mirror it such that our mirror benefits the entire neuroscience community (i.e., is accessible to everyone and simply helps reduce the network load on whatever groups are currently hosting it). https://temca2data.org/data.html
No due date