neurobox3d / neugen

NeuGen is made for generation of dendritic and axonal morphology of realistic neurons and networks in 3D

NeuGen

NeuGen is made for generation of dendritic and axonal morphology of realistic neurons and networks in 3D

NeuGen generates nonidentical neurons of morphological classes of the cortex, e.g., pyramidal cells and stellate neurons, and synaptically connected neural networks in 3D. It is based on sets of descriptive and iterative rules which represent the axonal and dendritic geometry of neurons by inter-correlating morphological parameters. The generation algorithm stochastically samples parameter values from distribution functions induced by experimental data. The generator is adequate for the geometric modelling and for the construction of the morphology.

The generated neurons can be exported into a 3D graphic format for visualization and into multi-compartment files for simulations with the program NEURON. NeuGen is intended for scientists aiming at simulations of realistic networks in 3D.

Build prerequisites

1. Ant >= 1.9
2. JDK >= 6 and JDK <= 12

Howto build NeuGen

1. Netbeans: Clean & Build
2. Ant: ant release from NeuGen folder

Howto run NeuGen

1. Netbeans: Run File NeuGenApp.java
2. Terminal: Go to rls folder - execute run script according to your OS

Releases

NeuGen 2.0 - git tag v2.0 Current development on devel branch, current stable on master branch. See also the project website NeuGen and NeuroBox3D.

Samples

neugen's Issues

Revise network generation

Due to the fact that the network generation has a very high memory footprint (>5000 Neurons with default parameters) we need to investigate this issue too - this occurs when using NeuGen only for generating the network!

Disentangle Network Generation from GUI for integration into VRL-Studio

Necessary, to use NeuGen within VRL.

We need to think about how to visualize the networks within VRL-Studio.

One possibility: Export to NGX/UGX and visualize UGX by JavaFX visualization implemented by Eugen?
(Then we would need probably the NeuronalTopologyImporter within VRL-Studio in case of NGX or not in case of UGX)

Library upgrade

Xstream should be upgraded, but current stable version of Xstream breaks NeuGen, figure out why.

NeuroML export

WIP, see Code todos.

1. Add ChannelML features (NeuroML Level 2)
2. Add Synapse Properties for Networks (NeuroML Level 3)
3. Add Populations Element for Networks (NeuroML Level 3)

Feel free to propose changes or features here.

Coarsen grids

Self-intersections in NeuGen-created cells

Cells created by NeuGen often contain several self-intersections. This is due to at least the following critical points:

• acute angles (local self-intersection),
• branching points where branching dendrite is almost parallel to original one,
• bad luck (nothing seems to prevent a new dendrite from going right through an existing one).

While this is not an issue for 1d simulations, it is if one tries to re-interpret the point/diameter information as a real 3d cell surface (using, e.g., AnaMorph). It would be preferable to create cells that are not self-intersecting (and thus more realistic). This should be relatively inexpensive.

I suppose (without having checked) that there are also intersections between neurons when creating networks. Avoiding this kind of intersection might be more involved (would probably require using some spatial indexing structure for dismissing definitely not intersecting segments fast).

.ugx grid output or .xml output

We need to serialize all relevant informations from the geometry NeuGen creates to a file to use within UG simulations... therefore it is crucial to enhance either .ugx format or use a custom .xml format to captuer these informations...

Things to do

Various TODOs within the NeuGen code - implement on demand.

Exporter for Networks (Refactoring)

Have to be refactored to allow for easier extension and use.

Netbeans Project -> Gradle

Refactor / Enhance NeuGen's backend

Refactoring:

1. Logging (Log4j)
2. Params map into a member

3 Dimensional models instead of 1D

Hello,

A couple of weeks ago i asked if it was possible to export files from Neugen to .ugx, which using the .txt export function worked out well. Now i wanted to know if there is any way in NeuGen to create 3 Dimensional Neurons like this one:

instead of the One Dimensional networks one gets from exporting the files:

Is there an option to do this or does this afford too much computing etc.?

Thanks in advance!

Hippocampal network export

We need to export the synapses here too,
this feature is currently not implemented!

Java3D 1.5 incompatible with newer OSX releases (>= Mountain Lion)

Update Java3D 1.5 to 1.6.

See also:
http://stackoverflow.com/questions/12738469/java3d-not-working-on-mac-mountain-lion
https://github.com/hharrison/
http://jogamp.org/

Use VRL-Studio libs from https://github.com/VRL-Studio/VRL-Studio/tree/java8/VRL-Studio/lib.

NeuroMLWriter

Suggested is the output of synapse too in the XML file (NeuroML Level 3)... currently investigating how to implement this.

Major todos for NeoCortex export

1. Refactor NGXDialog
2. Assign function to dist-synapse button...
3. Get default values from first sibilings
4. Cleanup new code

Tasks must be more flexible

See TODO in NeuroMLTaskWriter.java

Refactor Backend (extract class NGBackendProject)

Currently backend manages all,
this violates SRP and also may be confusing to use.

Use extract class refactoring and move method, move field to address this issue.
Add proper unity testing for backend code.

VRL-NeuGen-Project

Probably as another repository project (GUI in VRL-Studio for Network Generation which utilized the NGBackend)

UGX export for simulating Neurons

I am exploring the limits for simulating neurons for my masters thesis. The simulation runs with neuron grids saved as ugx files and the generated neurons in NeuGen would easily be implemented into my research if I somehow could access them as .ugx files.
Is there any way to export or transfer files to ugx?

Export incrementally and refactor export structures

Since exporting the network has many parts in common we should refactor this to allow for other people writing their own exporter with less amount of work...

inconsistent synapse export

Synapses are not exported consistently with the various export methods:

For a default project (new project Neocortex, defaults for all parameters)

• HOC exports more alpha synapses than NGX and TXT,
• the location of synapses exported as TXT, NGX and HOC are all different:
  • TXT: all synapses seem to be located at an end of a section,
  • NGX: all synapses seem to be located in a vertex,
  • HOC: synapses are located anywhere.

(Known) Bugs

1. Some parameters get cached within ConfigParserContainer (e. g. nparts_density, len_param, branch_angle and nbranch_param) - therefore we need to replace them in the config file before creating the project! (this is not attributed to the Comments Subtree component in the NeuGenApp view! - however the comments should also be updated accordingly in the GUI view!)

.hoc export

Hippocampal Networks don't export their synapses (needs implementation),
relative location in NetCon objects is not within bounds 0 <= rel_loc <= 1, we just warn.

Enhance interconnection process

If it is true that synapses are placed between any two segment pairs (axonal and dendritic) that are located within a specified distance from one another, then the number of synapses in the final network strongly depends on the length of the segments (roughly, in a quadratic manner).

While the main idea of connecting neurons where they are close to one another seems valid to me, the implementation should definitely be improved.

One might think about connecting only in local distance minima.

Deployment and Unit Testing

General:

1. Universal releases exist for Linux, Mac and Windows (zip) - execute run.sh or run.bat.
2. Installer for OSX exists (with all native libs though. improvement: provide only osx native j3d libs). To create a pkg installer there is an ant task provided.

Todos:

1. Installer for Linux and Windows (including JRE) to make feel the user more familiar (and provide for each installer only the linux or windows native libs for j3d)
2. Extension Directory of old JRE in Mac (/System/Library/Java/Extensions) is preloaded, prevent this and use j3d from bundled JRE when using the mac pkg installer.
3. Code sign mac bundle

NeuroML import/export

NeuGen only imports MorphML aka NeuroML Level 1 xml files.

Import:
Import Level 2 and Level 3 features.

Export:
Add Synapse Properties for Networks (NeuroML Level 3)
Add Populations Element for Networks (NeuroML Level 3)

NGX export for Hippocampal Networks and TXT export for Hippocampal Networks and NeoCortex issues

1. NGX export for HippoCampus: implement completely!
2. NGX export for NeoCortex: cleanup and see todos for that export below.

Compression for TXT export

Add possibility to compress TXT files.

NeuGen Executables (OSX > 10.10)

Currently, NeuGen does not run out of the box, i.e., pressing the run button in NetBeans causes reproducible errors (at least on macOS 10.12, JDK 1.8.x, devel-branch):

Exception in thread "AWT-EventQueue-0" java.lang.IllegalStateException: Application is not launched.
	at org.jdesktop.application.Application.checkApplicationLaunched(Application.java:692)
	at org.jdesktop.application.Application.getInstance(Application.java:666)
	at org.neugen.gui.NeuGenProject.initComponents(NeuGenProject.java:139)
	at org.neugen.gui.NeuGenProject.<init>(NeuGenProject.java:92)

Running NeuGen with the run.shscript works though. The problem with the run-Script, however, is that it does not have access to the correct classpath without manual configuration. The scripts themselves are problematic too: for example, they do only work if they are called from the correct directory since they can't figure out their own location on the filesystem. At least the documentation should be updated to allow new users/developers to run NeuGen without too much guess-work.

Rather than improving the current scripts, it might be a good idea to join forces with our VRL-Studio IDE where most problems regarding executables and installation have been solved. And we already use it as part of the NeuroBox toolchain anyway.

What do you think? Let me know if you need help.

Gradle

Convert the old-fashioned Netbeans project to a Gradle project and add Coveralls support (Travis CI and Waffle IO already working).

UGX export and import

One should add the possibility to export .ugx directly from NeuGen and potentially an import of .ugx to NeuGen should be available.

Enhance GUI-independent NeuGenBackend (NGBackend)

We need to think about how to visualize the networks within VRL-Studio.

One possibility: Export to NGX/UGX and visualize UGX by JavaFX visualization implemented by Eugen?
(Then we would need probably the NeuronalTopologyImporter within VRL-Studio in case of NGX or not in case of UGX)