2015 Brainhack Proceedings

Table of contents I1 Introduction to the 2015 Brainhack Proceedings R. Cameron Craddock, Pierre Bellec, Daniel S. Margules, B. Nolan Nichols, Jörg P. Pfannmöller A1 Distributed collaboration: the case for the enhancement of Brainspell’s interface AmanPreet Badhwar, David Kennedy, Jean-Baptiste Poline, Roberto Toro A2 Advancing open science through NiData Ben Cipollini, Ariel Rokem A3 Integrating the Brain Imaging Data Structure (BIDS) standard into C-PAC Daniel Clark, Krzysztof J. Gorgolewski, R. Cameron Craddock A4 Optimized implementations of voxel-wise degree centrality and local functional connectivity density mapping in AFNI R. Cameron Craddock, Daniel J. Clark A5 LORIS: DICOM anonymizer Samir Das, Cécile Madjar, Ayan Sengupta, Zia Mohades A6 Automatic extraction of academic collaborations in neuroimaging Sebastien Dery A7 NiftyView: a zero-footprint web application for viewing DICOM and NIfTI files Weiran Deng A8 Human Connectome Project Minimal Preprocessing Pipelines to Nipype Eric Earl, Damion V. Demeter, Kate Mills, Glad Mihai, Luka Ruzic, Nick Ketz, Andrew Reineberg, Marianne C. Reddan, Anne-Lise Goddings, Javier Gonzalez-Castillo, Krzysztof J. Gorgolewski A9 Generating music with resting-state fMRI data Caroline Froehlich, Gil Dekel, Daniel S. Margulies, R. Cameron Craddock A10 Highly comparable time-series analysis in Nitime Ben D. Fulcher A11 Nipype interfaces in CBRAIN Tristan Glatard, Samir Das, Reza Adalat, Natacha Beck, Rémi Bernard, Najmeh Khalili-Mahani, Pierre Rioux, Marc-Étienne Rousseau, Alan C. Evans A12 DueCredit: automated collection of citations for software, methods, and data Yaroslav O. Halchenko, Matteo Visconti di Oleggio Castello A13 Open source low-cost device to register dog’s heart rate and tail movement Raúl Hernández-Pérez, Edgar A. Morales, Laura V. Cuaya A14 Calculating the Laterality Index Using FSL for Stroke Neuroimaging Data Kaori L. Ito, Sook-Lei Liew A15 Wrapping FreeSurfer 6 for use in high-performance computing environments Hans J. Johnson A16 Facilitating big data meta-analyses for clinical neuroimaging through ENIGMA wrapper scripts Erik Kan, Julia Anglin, Michael Borich, Neda Jahanshad, Paul Thompson, Sook-Lei Liew A17 A cortical surface-based geodesic distance package for Python Daniel S Margulies, Marcel Falkiewicz, Julia M Huntenburg A18 Sharing data in the cloud David O’Connor, Daniel J. Clark, Michael P. Milham, R. Cameron Craddock A19 Detecting task-based fMRI compliance using plan abandonment techniques Ramon Fraga Pereira, Anibal Sólon Heinsfeld, Alexandre Rosa Franco, Augusto Buchweitz, Felipe Meneguzzi A20 Self-organization and brain function Jörg P. Pfannmöller, Rickson Mesquita, Luis C.T. Herrera, Daniela Dentico A21 The Neuroimaging Data Model (NIDM) API Vanessa Sochat, B Nolan Nichols A22 NeuroView: a customizable browser-base utility Anibal Sólon Heinsfeld, Alexandre Rosa Franco, Augusto Buchweitz, Felipe Meneguzzi A23 DIPY: Brain tissue classification Julio E. Villalon-Reina, Eleftherios Garyfallidis

Brainhacka novel conference model for the open neuroscience research community [1] exploded in 2015. With three-day events in Honolulu (June), Montréal (July), and across the Americas (eight participating sites in October) [http://events.brainhack.org/], a community that first began only a few years ago around the shared spirit of collaboration and an ethos of open science has taken resolute form. As Brainhack events were founded on the principle that content should emerge through the onsite interaction of participants, the innovative event structure demanded a different publication form. Inverting the model of conference proceedings, where submissions are triaged in preparation for the meeting, we developed the Brainhack Proceedings to rather mark the achievements, outputs, and ideas that emerged as the meeting's result. Post-conference papers were solicited from participants at any of the events held in 2015. All submissions were peer-reviewed in the Brainhack Proceedings Github repository [https://github.com/ Brainhack- Proceedings-2015] using an innovative open-review process. In keeping with the culture of Brainhack, we took advantage of the open platform provided by Github [http://github.com] to encourage a productive dialogue between authors and reviewers. This first issue of Brainhack Proceedings includes 23 project paperspresenting an overview of the broad range of interests, content, and achievements that converged at Brainhack events this past year. With at least four international events scheduled for 2016 [http:// events.brainhack.org], we hope that this publication format will provide an ongoing record of the growth within our community. Snapshots of all the projects and supporting information can be found in the GigaScience, GigaDB, repository [2]. For more information visit the Brainhack home page [http://brainhack.org].

Introduction
The past several decades have seen an explosive growth in the number of published neuroimaging studies. In concert, the demand for freely available and openly accessible 'study data' , that would facilitate future reanalysis, meta-analysis, hypothesis testing and repurposing has also soared. Here we report on developments made to Brainspell [1] one of several web-based initiatives (e.g. BrainMap [2], NeuroVault [3], Neurosynth [4]) that allow individuals to search through and organize massive numbers of neuroimaging studies and results in meaningful ways. Distinct from other databases, Brainspell [http://brainspell.org] is the first web-based initiative to allow users to manually annotate and curate machine-parsed data, as well as manually extend the database via its crowdsourcing user interface. The goal of our Brainhack project was to improve Brainspell's interface. We worked to (a) provide supplementary manual data edit options (b) facilitate efficient manual database extension, and (c) aid meaningful organization of data. Approach We used GitHub to manage the client and server code, and to coordinate its development.

Results Supplementary manual data edit options
In the original version of Brainspell, users were able to edit experiment (table) title, caption and coordinates for each article. We added four supplementary options. In particular, users are now provided with enhanced 'edit feedback':

Database extension
While users were previously able to add new articles and their coordinate tables, the process was labor-and time-intensive, since each value had to be manually entered. We implemented a more efficient method to edit tables: Addition of an Import link to each table. When clicked it opens a popup window where comma-separated text can be entered and parsed.
Meaningful organization of data Potential shortcomings of neuroimaging databases employing automatic coordinate data extraction is their inability to segregate (i) multiple contrasts (e.g. within group, inter-group), and (ii) significant versus nonsignificant coordinates, when present in a single table.
The following options were added to facilitate non-ambiguous data organization (see Fig. 1): Addition of a Split link to each table. Fine-tuning the Split link enhancement to allow more than ten splits.
Option to add articles lacking PMID (or user-specific articles). Addition of a Download link to each article. When clicked it downloads article title, reference, abstract, and tables.
Creation of 'article collection' functionality. Users can now store the results of their search into article collections. Clicking on an existing collection brings back the corresponding articles and re-computes the 3D volume and mesh of the aggregated locations. Users can create and edit multiple collections.

Conclusion
We performed ten enhancements to Brainspell and provided instructions of use in Brainspell's wiki. We tested these enhancements on Safari, Firefox and Chrome. Moreover, 25 articles were manually added to Brainspell as part of our extended beta testing phase. Our goal with these enhancements was to extend the functionality, and ease of use of Brainspell for curating machine-parsed neuroimaging data from a wide database of studies. During January 15 to February 5, 2016 alone, Brainspell was used in 282 sessions by 133 users who watched 1421 pages. Moreover, Brainspell was forked to "BIDS-collaborative/Brainspell" which itself was forked by approximately 10 data-science students to extend the platform. Availability of supporting data More information about this project can be found at: http://github. com/r03ert0/brainspell-brainhack.

Introduction
The goal of this project is to improve accessibility of open datasets by curating them. "NiData" aims to provide a common interface for documentation, downloads, and examples to all open neuroimaging datasets, making data usable for experts and non-experts alike. Approach Open datasets promise to allow more thorough analysis of hard-tocollect data and re-analysis using state-of-the-art analysis methods. However, open datasets are not truly open unless they are easy to find, simple to access, and have sufficient documentation for use. Currently, publicly available data in neuroscience are scattered across a number of websites and databases, without a common data format, no common method for data access, and varying levels of documentation. Datasets are being uploaded to public databases through a number of initiatives, including OpenFMRI [1] and NITRC [2] In addition, there are funded efforts for collecting data explicitly for the containing 32 articles. This user has a total of two collections (or 2 lists), as indicated on the header row. The second collection is named 'test'. b Highlighted in yellow are the Split and Import links associated with each table in Brainspell. Note: With the exception of the Download link, peer-login is required to access all mentioned Brainspell enhancements Introduction Data acquired during neuroimaging experiments can be organized in many ways. This stems from differences in scanner software, various DICOM and NIFTI tools, and custom data organizing scripts within different laboratories. The Brain Imaging Data Structure (BIDS) specification [1] provides a simple, straightforward solution to this problem by introducing an intuitive standard for neuroimaging data organization. The widespread adoption of BIDS can be facilitated through incorporating this standard into software projects used for neuroimaging analysis. These software packages will in turn benefit from the homogenous data structure and ease of specifying data acquisition parameters afforded by BIDS. The goal of this Brainhack project was to integrate BIDS into the Configurable Pipeline for the Analysis of Connectomes (C-PAC) [2] a Python Package? built on Nipype [3] for the high-throughput analysis of resting state fMRI data. Approach Processing data with C-PAC begins with specifying the paths of the anatomical and functional files to be processed, along with their corresponding acquisition parameters. This is accomplished in a semi-automatic procedure in which the user specifies templates that describe the file organization and then a script walks this structure to find the data. The resulting subject list can then be partnered with a pipeline configuration and submitted to C-PAC for processing. We extended this functionality to natively understand BIDS, so that data that conforms to this standard can be configured to run through C-PAC with minimal user intervention. C-PAC with BIDS A BIDS flag was added to the subject list builder along with a text box for the user to specify the base directory of the data file structure. The BIDS file hierarchy is then traversed to build anatomical and functional file pattern templates. These templates are returned to the main subject list builder function, which runs the same way as if using user specified file path templates. This approach minimized modifications to the data-gathering algorithm while providing for a robust way to ensure all data is found and returned properly. Additional scanning parameters that are required to complete the processing (repetition time, slice timing information, etc.) are read from BIDS specified JSON files that are stored alongside the imaging data. The new implementation takes advantage of one of many BIDS utilities openly available: the BIDS meta-data tool [4] [https://github.com/INCF/ bidsutils] This tool provides the subject, session, and run-level indicators to the builder without needing the user to manually enter any keywords; it takes advantage of the fixed organization scheme and the presence of JSON files to deliver all of this information reliably and efficiently. The tool is written in Python, which provided for easy integration into the C-PAC source code. It works for BIDS datasets stored locally as well as those available through remotely through Amazon S3.

Results
The updated C-PAC GUI reflects the "BIDS" and "Custom" options -as seen in Fig. 2 -with the "Custom" option allowing users to specify their data structure as in previous versions of C-PAC. In the future this option would be more elegantly displayed via a radio button with the input fields dynamically changing to reflect the type of input desired. The code changes were fairly straightforward and were cleanly inserted into the current builder module [https://github.com/FCP-INDI/C-PAC/blob/test_dev/CPAC/utils/build_sublist.py] The implementation developed during Brainhack is feature full, but will require more testing in the future.

Conclusions
Incorporating the BIDS subject list builder into C-PAC is a great step forward in bringing the standard to a broader audience. Throughout the integration process, other technologies were discovered that could further enable input data gathering across a wide range of file system types, including FTP, SFTP, Zip, S3, and an array of virtual filesystems. With further development, the overhead of preprocessing one's own neuroimaging data for discovery science can be minimized so scientists can focus on the results.

Availability of supporting data
More information about this project can be found at: https:// bids.neuroimaging.io.

Introduction
Degree centrality (DC) [1] and local functional connectivity density (lFCD) [2] are statistics calculated from brain connectivity graphs that measure how important a brain region is to the graph. DC (a.k.a. global functional connectivity density [2]) is calculated as the number of connections a region has with the rest of the brain (binary DC), or the sum of weights for those connections (weighted DC) [1]. lFCD was developed to be a surrogate measure of DC that is faster to calculate by restricting its computation to regions that are spatially adjacent [2]. Although both of these measures are popular for investigating inter-individual variation in brain connectivity, efficient neuroimaging tools for computing them are scarce. The goal of this Brainhack project was to contribute optimized implementations of these algorithms to the widely used, open source, AFNI software package [3] Approach Tools for calculating DC (3dDegreeCentrality) and lFCD (3dLFCD) were implemented by modifying the C source code of AFNI's 3dAu-toTcorrelate tool. 3dAutoTcorrelate calculates the voxel X voxel correlation matrix for a dataset and includes most of the functionality we require, including support for OpenMP [4] multithreading to improve calculation time, the ability to restrict the calculation using a user-supplied or auto-calculated mask, and support for both Pearson's and Spearman correlation. 3dDegreeCentrality Calculating DC is straightforward and is quick when a correlation threshold is used. In this scenario, each of the .5*N vox /(N vox -1) unique correlations are calculated, and if they exceed a user specified threshold (default threshold = 0.0) the binary and weighted DC value for each of the voxels involved in the calculation are incremented. The procedure is trickier if sparsity thresholding is used, where the top P% of connections are included in the calculation. This requires that a large number of the connections be retained and ranked -consuming substantial memory and computation. We optimize this procedure with a histogram and adaptive thresholding. If a correlation exceeds threshold it is added to a 50-bin histogram (array of linked lists). If it is determined that the lowest bin of the histogram is not needed to meet the sparsity goal, the threshold is increased by the bin-width and the bin is discarded. Once all of the correlations have been calculated, the histogram is traversed from high to low, incorporating connections into binary and weighted DC until a bin is encountered that would push the number of retained connections over the desired sparsity. This bin's values are sorted into a 100-bin histogram that is likewise traversed until the sparsity threshold is met or exceeded. The number of bins in the histograms affects the computation time and determines the precision with which ties between voxel values are broken. A greater number of bins allow the sparsity threshold to be determined more precisely but will take longer to converge. Fewer bins will result in faster computation but will increase the tendency of the algorithm to return more voxels than requested. The chosen parameters enable ties to be broken with a precision of 1.0/(50*100), which in our experience offers quick convergence and a good approximation of the desired sparsity. 3dLFCD lFCD was calculating using a region growing algorithm in which face-, side-, and corner-touching voxels are iteratively added to the cluster if their correlation with the target voxel exceeds a threshold (default threshold = 0.0). Although lFCD was originally defined as the number of voxels locally connected to the target, we also included a weighted version. Validation Outputs from the newly developed tools were benchmarked to Python implementations of these measures from the Configurable Pipeline for the Analysis of Connectomes (C-PAC) [5] using the publicly shared Intrinsic Brain Activity Test-Retest (IBATRT) dataset from the Consortium for Reliability and Reproducibility [6]. Results AFNI tools were developed for calculating lFCD and DC from functional neuroimaging data and have been submitted for inclusion into AFNI. LFCD and DC maps from the test dataset (illustrated in Fig. 3) are highly similar to those calculated using C-PAC (spatial concordance correlation [7] 0.99) but required substantially less time and memory (see Table 1).

Conclusions
Optimized versions of lFCD and DC achieved 4x to 10x decreases in computation time compared to C-PAC's Python implementation and decreased the memory footprint to less than 1 gigabyte. These improvements will dramatically increase the size of Connectomes analyses that can be performed using conventional workstations. Making this implementation available through AFNI ensures that it will be available to a wide range of neuroimaging researchers who do not have the wherewithal to implement these algorithms themselves.
Availability of supporting data More information about this project can be found at: http://github. com/ccraddock/afni

Introduction
The purpose of this Brainhack project was to create a simple application, with the least dependencies, for anonymization of DICOM files directly on a workstation. Anonymization of DICOM datasets is a requirement before an imaging study can be uploaded in a web-based database system, such as LORIS [1]. Currently, a simple and efficient interface for the anonymization of such imaging datasets, which works on all operating systems and is very light in terms of dependencies, is not available.

Approach
Here, we created a DICOM anonymizer that is a simple graphical tool that uses PyDICOM [https://github.com/darcymason/pydicom] package to anonymize DICOM datasets easily on any operating system, with no dependencies except for the default Python and NumPy packages. DICOM anonymizer is available for all UNIX systems (including Mac OS) and can be easily installed on Windows computers as well (see PyDICOM installation [http://pydicom.readthedocs.org/en/latest/getting_started.html]). The GUI (using tkinter [https://wiki.python.org/moin/TkInter]) and the processing pipeline were designed in Python. Executing the anonymizer_gui.py script with a Python compiler will start the program. Figure 4 illustrates how to use the program to anonymize a DICOM study.

Results
This graphical tool, designed to be easy-to-use, platform independent and have minimum dependencies, produces two zip files. One zip file includes the original DICOM files and the other contains the anonymized DICOM outputs.

Conclusions
The DICOM anonymizer is a simple standalone graphical tool that facilitates anonymization of DICOM datasets on any operating system. These anonymized studies can be uploaded to a web-based database system, such as LORIS, without compromising the patient or participant's identity. Availability of supporting data More information about this project can be found at: http://github.com/aces/DICOM_anonymizer.

Competing interests None
Author's contributions SD, CM, AS, and ZM wrote the software and the report.  . Whole brain maps of binarized and weighted degree centrality calculated with a correlation threshold of 0.6 (a-b) and sparsity threshold of 0.1 % (c-d) and binarized and weighted lFCD calculated with a correlation threshold of 0.6 (e-f) averaged across maps calculated the first resting state scan of the first scanning session for all 36 participants' data from the IBATRT data

Introduction
Our ability to quantitatively study large-scale social and behavioural phenomena such as peer influence and confirmation bias within scientific circles rest on quality and relevant data [1] Yet the compilation of specific coauthorship databases are often restricted to certain well-defined fields of study or publication resources, limiting the extent and depth by which investigations can be performed. Ultimately, we aim to understand how the social construct and its underlying dynamics influence the trajectories of scientific endeavors [2] This work is motivated by an interest in observing social patterns, monitoring their evolution, and possibly understanding the emergence and spreading of ideas and their biases in the neuroimaging community; central themes to deciphering facts from opinions. However, before being able to fully investigate and address these fundamental and inherently complex questions, we need to address the extraction and validation of data. The goal of this project was to leverage publicly available information on Google Scholar (GS) to automatically extract coauthorship networks.

Approach
The tool can be accessed through a public website [http://cos.dery.xyz]. The site is constructed using a set of openly accessible libraries allowing the display of coauthorship networks as interactive graphs [3] Visitors can peruse a set of pre-computed networks extracted using custom Python scripts designed to crawl GS based on a set of predefined constraints (e.g. search topic, publication journal). The proposed interface offers seamless manipulation to keep interaction straightforward and easy to use. The simplicity of the design aims to reach a maximum number of users, assuming a minimal level of technical knowledge.

Graph Construction:
Scholarly citations are commonly found in standardized format, suggesting the structure can be reliably used within an automatic procedure. Moreover, while the result of typical search engines are not structured towards data mining (i.e. mixture of natural language embedded in semi-structured tags and page links), particular combinations of HTML tags and CSS identifiers can be leveraged to extract specific information. This simple scheme allows the reconstruction of large-scale networks of collaborations. Interestingly, Google Scholar also hosts individual pages for authors' rich with pre-computed metrics of scientific productivity and impact (e.g. cumulative number of citations, h-index, i10-index). This data can be further exploited to structure and highlight part of the network. Community Detection: Scientific communities were detected using a greedy agglomerative modularity optimization process [4] Validation: To assess the recovered network's reliability we performed a spot check on its content. First we examined the accuracy of 100 randomly selected researchers from the network and sought after their departmental affiliation and publication journals to confirm their belonging to the broad field of neuroimaging. The dependence on profile availability injects a strong negative bias. To better appreciate the crawling ability to construct network we further compare with the number of members having a Google Scholar page in the form of a corrected accuracy.
Results 96 researchers were confirmed to have direct institutional affiliation to neuroscience, psychology, or biomedical engineering departments (see Fig. 5). The remaining 4 randomly selected researchers were found to work in the fields of human genome sequencing, image analysis, nano particles, and pharmacology. Note that these individuals were located on the outskirts of the main graph. To further assess completeness of the network, we compared results with faculty rosters of 5 major neuroimaging institutes ( Table 2).

Conclusions
Accuracy results suggest a sufficient number of individuals are registered through GS to make it a useful platform of discovery. Meticulous inspection of the grouping suggest that communities typically embed either a geographical or a topical component, that is to say, certain communities are seemingly brought together by either proximity or similarity of interest. With the increasing complexity of science, finding accurate and relevant information on specific topics is a challenging task. We feel that a better appreciation of the wealth and variety of opinions within scientific communities may help enforcing the notion that grand claims require grand evidence.
Availability of supporting data More information about this project can be found at: http://github.com/sderygithub/Clubs-of-Science.

Introduction
The purpose of developing yet another web-based image viewer, Nif-tyView, is to use WebGL to take advantage of the parallel computing power in Graphics Processing Units (GPU) hardware for the acceleration of rendering and processing of medical images in web applications. The contrast and brightness of images can be adjusted by clicking and holding the right mouse button or using a double slider widget in the horizontal tool bar at the top of the window. For proof-of-concept, functions such as pixel windowing and scaling are programmed using WebGL by translating the arithmetic operations in image processing to 3D graphics primitives using WebGL's programmable shaders. The pixel values of an image are loaded into a frame buffer. A vertex shader is programmed to define vertices corresponding to the coordinates of the image, and a fragment shader is programmed to perform arithmetic operations, which are performed in parallel to a massive number of image pixels.

Discussion
One of the major limitations of current web-based image viewers is the slow performance compared to their desktop counterparts. There are collective efforts in industry to develop new technologies such as WebAssmebly and WebGL to narrow this performance gap. The highly parallel nature in processing image pixels independently allows the use of WebGL to achieve a significant speedup, as shown in this abstract. Currently, there are several similar existing web applications such as Papaya, BrainViewer, and slicedrop.com, which are more mature and offer varieties of features. However, the main goal of the continuing effort in the development of NiftyView is to achieve a high performance for image processing using GPU via WebGL. NiftyView has a minimal boilerplate and can handle a large number of files with relative ease. Future work will be focused on developing a WebGLaccelerated version, adding more image processing features, and adding support of accessing files stored in HIPAA (Health Insurance Portability and Accountability Act) compliant cloud storage services such as Box and Amazon S3. The stable version of Nifty-View will be released under a General Public License that allows end users to freely run, modify, and share the program.

Conclusion
NiftyView is a free and convenient web application for quick and easy viewing of NIfTI and DICOM medical images. We have shown that a factor of six to eight acceleration can be achieved using WebGL for image processing.
Availability of supporting data More information about this project can be found at: http:// www2.hawaii.edu/~weiran/NiftyView.html

Competing interests
None.

Introduction
The goal was to convert the Human Connectome Project (HCP) Minimal Preprocessing Pipelines into Nipype code. The HCP minimal preprocessing pipelines [1] represent a significant advance in image processing pipelines in our time. They provide preprocessed volume and surface data in native and atlas space, for both functional and structural data. Nipype is an open source neuroimaging project for designing imaging pipelines which has been around since 2011 and provides many excellent features for provenance and reliability of processing pipelines [2]. Together, these two pieces of software would allow for a more robust, more flexible synergy of pipeline design and operability. Approach The first goal was to train the would-be Nipype developers on the Nipype python standards for writing and running interfaces. Once trained, the plan was to implement the HCP scripts into Nipype interfaces from the top-level inward to the sub-level scripts. The secondary goal was to make these sub-level scripts more flexible and require less specific scans to run the pipelines. The collection of nine ultimate pipelines to implement were with or without T1s or T2s and with or without Fieldmap or Reverse-Phase-Encode EPIs as seen in Table 3.

Results
Conceptually these goals sounded reasonable enough to do all HCP scripts at once during the hackathon, but the learning and additional setup time was not accounted for, so the scope of the project was too big for two days of on and off coding, even among our eleven developers. Distributing Nipype knowledge from two experts to nine novices over two days was not an easy beginning task, but most of the novices had gained knowledge of Nipype usage by the end of the hackathon. Some work began during the hackathon converting HCP scripts into Nipype pipelines, however not much progress was made due to the unanticipated large scope of work. The second day, an epiphany came about that the original goal, as stated, would have only involved making five top-level wrappers for the five HCP top-level scripts. This also slowed some progress. The secondary goal of generalizing the HCP scripts was discussed, but not thoroughly explored or documented. There has only been some progress in generalization I am aware of in the Neuroimaging Lab (PI: Damien Fair, PA-C, PhD), at OHSU. This turnout of developers during an open hackathon is encouraging and demonstrates the importance of trying to fuse these two systems (Nipype and the HCP scripts) to work together. Work on the repository halted after the hackathon, but the team is still available.

Conclusions
More work is needed to truly contribute back to the HCP Pipelines https://github.com/Washington-University/Pipelines. The greatest achievement of the hackathon project was forming a collaborative team of interested Nipype developers who were trained and are ready to continue collaborating across seven institutions. Future work will continue trying to achieve the original goals as stated, but may need an organizer to hold the team accountable to deadlines. To get involved with this project, please contact Eric Earl, earl@ohsu.edu.

Availability of supporting data
More information about this project can be found at: https://github. com/ericearl/hcp2nipype-hack2015/

Competing interests
None.
Author's contributions EE wrote the report, EE and all other authors wrote the software.  Resting-state fMRI (rsfMRI) data generates time courses with unpredictable hills and valleys. People with musical training may notice that, to some degree, it resemble the notes of a musical scale. Taking advantage of these similarities, and using only rsfMRI data as input, we use basic rules of music theory to transform the data into musical form. Our project is implemented in Python using the midiutil library The lowest tone that can be played in a certain key was calculated from (key % 12) + 36. The set of tones that could be played were then determined from the lowest tone using a scale. For example, the minor-pentatonic scale's set of were calculated by adding 0, 3, 5, 7, or 10 to its lowest tone, then skipping to the next octave, and then repeating the process until the value 84 was reached. An fMRI time course was mapped to these possible tones by scaling its amplitude to the range between the smallest and largest tones in the set. If a time point mapped to a tone that was not in the set, it was shifted to the closest allowable tone. An example of allowed set of tones is shown in Fig. 8. For tempo, we used first temporal derivative for calculating the length of notes, assuming we have 4 lengths (whole, half, quarter and eighth note). In the time course, if the modulus distance between time point t and t + 1 was large, we interpreted it as a fast note (eighth). However, if the distance between t and t + 1 was close to zero, we assumed it is a slow note (whole). Using this approach, we mapped all other notes in between. We used a naive approach for calculating volume in a way that tackles a problem we had with fast notes: their sound is cut off due to their short duration. A simple way to solve this is to decrease the volume of fast notes. Thus, the faster the note, the lower the volume. While a whole note has volume 100 ([0,100]), an eighth note has volume 50. Finally, we selected the brain regions that will play. Users complain when two similar brain regions play together. Apparently, the brain produces the same music twice. However, when the regions are distinct, the music is more pleasant. Thus, we used FastICA [5] for choosing brain regions with maximally uncorrelated time courses.

Results
A framework for generating music from fMRI data, based on music theory, was developed and implemented as a Python tool yielding several audio files. When listening to the results, we noticed that music differed across individual datasets. However, music generated by the same individual (4 preprocessing strategies) remained similar.
Our results sound different from music obtained in a similar study using EEG and fMRI data [6] Conclusions In this experiment, we established a way of generating music with open fMRI data following some basic music theory principles. This resulted in a somewhat naïve but pleasant musical experience. Our results also demonstrate an interesting possibility for providing feedback from fMRI activity for neurofeedback experiments.

Availability of Supporting Data
More information about this project can be found at: https://github.com/carolFrohlich/brain-orchestra

Competing interests
None.
Author's contributions CF wrote the software. GD designed the functions for transforming the data to midi. DSM pick the algorithm that chooses ROIs, and CF and RCC wrote the report.  Python-based software package for performing time-series analysis on neuroscience data. Implementation of useful time-series features into python, and potential integration with Nitime, would not only facilitate their use by the neuroscience community, but also their maintenance and development within an open source framework. Approach An illustration of the approach is shown in Fig. 9 Each time series is converted to a vector of thousands of informative features using the hctsa package; machine-learning methods can then be used to determine the most useful features (e.g., that best discriminate patient groups, and where in the brain the best discrimination occurs).
In this project, we wanted to demonstrate a feasible pathway for incorporating these useful features into the Nitime package.
Results I successfully implemented a handful of basic time-series analysis functions from Matlab into python using partials (a python function that freezes a given set of input arguments to a more general function).
The proof-of-principle implementation has full support for vectors of data stored in numpy arrays, and basic support for the Nitime data format (extracting the data vector from the Nitime TimeSeries class for evenly sampled data).

Conclusions
Our results demonstrate that time-series analysis methods, discovered using the hctsa package [https://github.com/benfulcher/hctsa], can be implemented natively in python in a systematic way, with basic support for the time-series format used in Nitime. This will help facilitate future work on time-series analysis to be incorporated straightforwardly into this open source environment.
Although there are no plans to reimplement the full hctsa feature library in python, our hope is that published work describing useful time-series features (discovered using the hctsa library) can also contribute to a Python implementation, to promote its use by the neuroscience community.
Availability of supporting data More information about this project can be found at: https://github. com/benfulcher/hctsa_python

Competing interests
None.
Author's contributions BF wrote the software and the report.   9 (abstract A10). Illustration of the highly comparative approach to time-series data from neuroscience

Introduction
We aim at the large-scale, automatic sharing of software tools between neuroimaging processing platforms, which will increase the relevance of such platforms by providing them with richer repositories of higher-quality tools. Currently, efforts are hampered by the repetitive porting of the same few tools in different platforms. During the HBM 2015 Hackathon, we worked on the export of software tools from the Nipype workflow engine [1] to the CBRAIN web platform for distributed computing [2]. Nipype includes a large number of tools that would be useful to CBRAIN users.

Approach
We developed nipype2boutiques, a tool to export Nipype interfaces to the "Boutiques" tool description format (step 1. on Fig. 10.). Boutiques descriptions are importable by CBRAIN and other platforms (Virtual Imaging Platform [3] and the Pegasus workflow engine [4]). They point to a Docker image containing the implementation of the tool. nipype2boutiques relies on nipype_cmd a tool to run Nipype Interfaces as Linux command lines. nipype2boutiques parses the inputs and outputs of a Nipype interface and extracts their name, type, description and position on the nipype_cmd command line. nipype2boutiques then generates a Boutiques descriptor pointing to a Docker image where the Nipype interface is available. Once a Nipype interface is exported using nipype2boutiques it can be imported to CBRAIN.

Results
We tested nipype2boutiques on a few Nipype interfaces from the FSL Nipype module. We exported 64 FSL tools automatically from Nipype to CBRAIN, and made them available [https://github.com/glatard/boutiques-nipype-fsl]. Limitations remain on the type of Nipype interface that can be exported by nipype2boutiques: in particular, InputMultiPath is? currently not supported, and output files have to be written in the execution directory of the Nipype Interface.

Conclusions
We prototyped a software tool to export Nipype Interfaces as Boutiques descriptors, which can be imported by CBRAIN and other platforms. Although the solution is still limited to simple interfaces, we believe that it has the potential to enable fully automatic tool sharing between Nipype and CBRAIN. Future extensions of nipype2boutiques will be published in the Nipype Github repository [https://github. com/nipy/nipype]. We also plan on a tighter integration of Nipype workflows in CBRAIN, following the model adopted in [5].

Availability of Supporting Data
More information about this project can be found at: http:// cbrain.mcgill.ca.

Competing interests
None.
Author's contributions TG wrote the software and the report; SD contributed to the concept elaboration at the OHBM event, RA, NB, PR and MER provided support on the CBRAIN framework, RB implemented Boutiques in CBRAIN, NKM provided background information on fMRI packages, ACE spearheaded the project.

Introduction
Data analysis software and canonical datasets are the driving force behind many fields of empirical sciences. Despite being of paramount importance, those resources are most often not adequately cited. Although some can consider this a "social" problem, its roots are technical: Users of those resources often are simply not aware of the underlying computational libraries and methods they have been using in their research projects. This in-turn fosters inefficient practices that encourage the development of new projects, instead of contributing to existing established ones. Some projects (e.g. FSL [1]) facilitate citation of the utilized methods, but such efforts are not uniform, and the output is rarely in commonly used citation formats (e.g. BibTeX). DueCredit is a simple framework to embed information about publications or other references within the original code or dataset descriptors. References are automatically reported to the user whenever a given functionality or dataset is being used. Approach DueCredit is currently available for Python, but we envision extending support to other frameworks (e.g., Matlab, R). Until DueCredit Fig. 10 (abstract A11). System architecture gets adopted natively by the projects, it provides the functionality to "inject" references for 3rd party modules. For the developer, DueCredit implements a decorator @due.dcite that allows to link a method or class to a set of references that can be specified through a doi or BibTeX entry. For example (from PyMVPA):

Results
The initial release of DueCredit (0.1.0) was implemented during the OHBM 2015 hackathon and uploaded to pypi and is freely available. DueCredit provides a concise API to associate a publication reference with any given module or function. For example: To provide a reference for an entire module the cite function can be used, while functions and methods can be conveniently decorated using dcite. DueCredit comes with a simple demo code, which demonstrates its utility. Running a sample analysis produces a summary of references. At each run, the information is stored in a pickled file, and incremental runs update that file. Thus, DueCredit summary can be used to show that information again or export it as a BibTeX file ready for reuse.

Conclusions
DueCredit is in its early stages of development, but two days of team development at the OHBM hackathon were sufficient to establish a usable prototype implementation. Since then, the code-base was further improved and multiple beta-releases followed, expanding the coverage of citable resources (e.g., within scipy, sklearn modules via injections and PyMVPA natively).
Availability of supporting data More information about this project can be found at: https://github.com/duecredit/duecredit

Competing interests
None.
Author's contributions YOH and MVdOC performed the project and wrote the report.

Introduction
In dogs, the perception of an important stimulus can be related to physiological changes such as the heart rate (e.g., in socioemotional situations with humans [1] or dogs [2]) and the movement of their tail (for example, tail-wagging has a bias that depends on the nature of the stimulus, a bias to the left is related to a withdrawal tendency and a bias to the right is related to an approach tendency [3]). Although heart rate and the tail movement are important gateways to understanding dog cognition, just a few studies report these variables. Perhaps this is related to the difficulty of obtaining records of these variables in natural environments (e.g., parks), the elevated cost of commercial data acquisition hardware (around 5,000 USD [4]) or by nonexistence of a tail-movement registering device. For these reasons, the goal of this Brainhack project is to design and build a low cost device able to register the heart rate and changes in the tail movement in dogs, both in laboratory and in free movement conditions. Approach We decided to base our design in Arduino hardware for its accessibility and broad use. The materials are detailed in the Table 4. We designed and 3d printed a PLA case to contain the circuit. The case has a slot to add a strap to fix the device on the dogs back. The program for the Arduino and the model for the case can be downloaded from the GitHub (scripts directory) repository of the project.
In order to assess if the device could reliably get readings from a dog, we tested it in three phases: baseline, stimulation/no-stimulation and free movement. All phases lasted two minutes and were repeated twice on two dogs. In both, baseline and stimulation/nostimulation, the dog stayed in sphinx position without movement restrictions but under the command "stay". The stimulation/no-stimulation phase consisted in three interleaved repetitions of two types of conditions, stimulation and no-stimulation, each repetition lasted 20 s. In the stimulation condition the dog owner showed the dog a treat and mentioned the dog's name. In the free movement condition, the dog walked down a street without any specific command.

Results
In the stimulation/no-stimulation phase a Wilcoxon Signed Rank Test revealed statistically significant differences (p < 0.05) between the beats per minute, beat amplitude and the tail movement amplitude (Fig. 11). By matching the data collected with observations of the movement of the tail, we notice that the data reflects the position of the tail but its resolution depended on the position of the electrode. The data acquired from the free movement condition was affected by the movement and did not seem reliable for testing.

Conclusions
We were able to build and test a non-invasive low cost device with the capacity to register the heart rate and the tail movement of dogs. We consider that the addition of a movement sensor could provide additional data to reduce the change on the signal due to movement. This device can be integrated in future research on dog cognition. It can also be used in shelters and homes to easily measure the responses that dogs present to different sets of stimuli; for example, when a dog is left alone in its house and shows stress (i.e. increased heart rate, preferential tail movement to the left) the dog's care giver could make changes in the environment to increase the well-being of the dog. The low cost and the easy access to the materials needed to build the device make it a feasible option to study dog cognition. The results showed that the device could be used to distinguish between two different stimulation conditions. Availability of supporting data More information about this project can be found at: https://github.com/nekrum/DogVest.

Competing interests None
Author's contributions LVC generated the idea for the project, made the research, help writing the report and acquire the data. EAM and RH designed the device, build it, wrote the code and helped write the report.

Introduction
The laterality index (LI) is one way to assess hemispheric dominance in a variety of tasks, such as language, cognitive functions, and changes in laterality in clinical populations, such as after stroke. In stroke neuroimaging, however, an optimal method of calculating the LI remains controversial, largely due to lesion variability in poststroke brains. Two main methods of calculating LI have evolved in neuroimaging literature [1] The first, more traditional approach counts the number of active voxels in a given region of interest (ROI) for each The table shows most of the materials used and their approximated cost with a local provider. Other materials were used but their cost is negligible hemisphere. This method has been criticized for its inability to account for differences in signal intensity. Hence, a second approach calculates laterality based on the percent signal change within a given region; however, this method also has problems, such as difficulty handling negative values. A laterality toolbox that addresses some of these issues has been implemented in the statistical neuroimaging analysis package SPM, which provides users with options of using either method, along with more advanced statistical tests for robust LI calculations [2] No such toolbox is yet available for FSL. Therefore, we developed a series of scripts to calculate LI in FSL using both voxel count and percent signal change methods. However, in the interest of space, here we present only results from the more robust method of the two (voxel count method).

Approach
We used fMRI data from two groups of stroke participants who either had right or left hemisphere lesions. Participants observed videos of right or left hand actions, and resulting statistical maps were calculated for each individual. The LI was then calculated per participant, based on the number of active voxels within a given anatomicallydefined ROI (the inferior frontal gyrus, pars opercularis). Using the cluster tool in FSL, we set a threshold on the second-level wholebrain map. We set a range of z-values (z = 1.0, z = 1.5, z = 2.3) to test the effects of different thresholds. We then utilized fslstats to determine the total number of active voxels in both left and right hemisphere ROIs. Finally, we calculated LI based on the equation: where L represents the number of active voxels in the lefthemisphere ROI and R is the number of active voxels in the righthemisphere ROI. This yields a value for LI such that −1 < LI < +1, where a positive value indicates left-hemisphere dominance and a negative value indicates right-hemisphere dominance.

Results/Discussion
We examined the variability in LI at different z-value thresholds to look at laterality differences in individuals with cortical versus subcortical stroke as well as the affected hemisphere (R vs. L). The LI values of four representative individuals (see Fig. 12) with the following types of stroke were as follows (see Table 5): subcortical left-hemisphere stroke (mean LI = −0.23; right lateralized), subcortical right-hemisphere stroke (mean LI = 0.79; left lateralized), cortical left-hemisphere stroke (mean LI = 0.96, left lateralized), and cortical right-hemisphere stroke (mean LI = 0.94, left lateralized). These LI results corresponded with our whole brain observations (not included here). Importantly, we notice that the voxel count method is highly dependent on the threshold value: as the threshold increases in stringency, the value of the LI increases. With individuals after stroke, higher thresholds may yield 0 active voxels, leading to a potentially skewed LI (LI = 1).

Conclusions
We suggest that stroke neuroimaging might benefit from calculating an average LI across different thresholds (including more lenient thresholds such as z = 1.0), in order to provide a more robust outcome that takes into account threshold dependency. This is especially true for individuals with cortical strokes, where the ROI may overlap with the lesion and yield 0 active voxels. This issue of thresholding, specifically for stroke research, is an interesting question that remains to be addressed further. Our scripts for these calculations may be found online at the NPNL resource page [http://chan.usc.edu/npnl/resources].

Availability of supporting data
More information about this project can be found at: http://github.com/npnl/LI_FSL  [2]. The goal of this work is to enhance the efficiency and usability of the workflow by allowing it to take advantage of the increasing availability of high performance computing resources. Nipype also enhances the modularity of the workflow which allows for algorithms from other packages (e.g., ANTS [3] FSL [4] BRAINSTools [5] to be explored, added into the workflow, or take the place of existing processing steps. Therefore, the Nipype environment permits increased collaboration on the recon-all workflow and allows for the limitations of the workflow to be easily addressed. Approach Nipype interfaces were created for the tools used in the recon-all workflow. These interfaces allow developers to recreate in a Nipype workflow the exact same commands used in the FreeSurfer's tcsh script. The Nipype version of the recon-all workflow was then created by using the Nipype interfaces to connect the FreeSurfer commands in the order necessary. To verify that the new Nipype workflow is equivalent to FreeSurfer's recon-all workflow, both workflows were run on the same set of MRI images on multiple platforms (CentOS 6.4 and Mac OS X) and in a high-performance computing environment. Output surface files were converted to VTK file format, and the output image files were converted to NIFTI file format. The images and surfaces output from FreeSurfer's recon-all workflow were compared to the outputs from Nipype recon-all workflow.

Results
All output images and surfaces from FreeSurfer's recon-all were identical to those of the Nipype workflow that was run on the same operating system (see Fig. 13). During testing on a 16 Core CentOS 6.4 machine with 64GB of memory, FreeSurfer's recon-all workflow completed processing in over 8.9 hours. With multiprocessing, the Nipype workflow achieved identical results and completed processing in under 6 hours when tested on the same machine.

Conclusions
The Nipype workflow created in this project was shown to be equivalent to the pre-existing FreeSurfer recon-all workflow. Furthermore, by utilizing Nipype's ability to run commands in parallel, the new workflow reduces the running time of recon-all by over 30% when compared to FreeSurfer's recon-all script which runs commands in a sequential order. The Nipype environment also allows for increased collaboration in further developing the workflow. Future work will involve incorporating more options to the Nipype workflow so that it can function as a complete replacement for the tcsh shell script. The collaborations at the 2015 OHBM BrainHack meeting were instrumental in accomplishing this task. Collaborations with the FreeSurfer, Nipype, and Human Connectome teams allowed members of this project to quickly identify problems and avoid unnecessary failures.

Availability of supporting data
The resulting workflow from this project can be found at: https:// github.com/nipy/nipype. An example of how to run the workflow on the tutorial data can be found at: https://github.com/nipy/nipype/ blob/master/examples/smri_fsreconall.py.

Competing interests
None.
Author's contributions HJJ performed the project and wrote the report. DGE created Nipype interfaces for the FreeSurfer commands, scripted the Nipype workflows, ran the workflow output comparisons, and contributed to the report. IO and RK advised on the project and contributed to the report. Fig. 13 (abstract A15). Visualization of the cortical thickness projected onto the left hemisphere's inflated surface for both the FreeSurfer(left) and Nipype workflows as well as the difference the two thicknesses(right). The thickness measurements showed no difference between the workflows Introduction A vast number of clinical disorders may involve changes in brain structure that are correlated with cognitive function and behavior (e.g., depression, schizophrenia, stroke, etc.). Reliably understanding the relationship between specific brain structures and relevant behaviors in worldwide clinical populations could dramatically improve healthcare decisions around the world. For instance, if a reliable relationship between brain structure after stroke and functional motor ability was established, brain imaging could be used to predict prognosis/recovery potential for individual patients. However, high heterogeneity in clinical populations in both individual neuroanatomy and behavioral outcomes make it difficult to develop accurate models of these potentially subtle relationships. Large neuroimaging studies (n > 10,000) would provide unprecedented power to successfully relate clinical neuroanatomy changes with behavioral measures. While these sample sizes might be difficult for any one individual to collect, the ENIGMA Center for Worldwide-Medicine, Imaging, and Genomics has successfully pioneered metaand mega-analytic methods to accomplish this task. ENIGMA [http:// enigma.ini.usc.edu] brings together a global alliance of over 500 international researchers from over 35 countries to pool together neuroimaging data on different disease states in hopes of discovering critical brain-behavior relationships [1,2] Individual investigators with relevant data run ENIGMA analysis protocols on their own data and send back an output folder containing the analysis results to be combined with data from other sites for a meta-analysis. In this way, large sample sizes can be acquired without the hassle of large-scale data transfers or actual neuroimaging data sharing. ENIGMA protocols were initially developed to harmonize processing methods of imaging researchers around the world and they require a moderate level of familiarity with several programming languages and environments. However, ENIGMA's recent success has attracted greater interest in collaborative neuroimaging and protocols must be adjusted to allow for all levels of experience, as, the success of this approach depends on individual collaborators running these ENIGMA protocols on their data. Here, we worked on simplifying these protocols so even a novice programmer could use them. In this way, we hope to expand the feasibility of collecting critical clinical data from collaborators who may have less experience with neuroimaging techniques.

Approach
The current ENIGMA protocols [http://enigma.ini.usc.edu/protocols/] for structural neuroimaging analyses consist of a number of different word documents with embedded links to different scripts and snippets of code that use R [3], Bash scripting [4], Matlab [5], FSL [6], and Freesurfer [7]. Each step must be run sequentially, costing the user time during the implementation to wait for each step to finish before beginning the next. In addition, the number of different scripts, programming languages and software environments can be challenging for a novice user and introduces numerous instances where the individual may make errors in implementing the code. To address this, we created 3 easy-to-use wrapper scripts that automate the implementation of the ENIGMA protocols for both subcortical and cortical structural MRI analyses (see Table 6). These wrapper scripts reduce over 40 steps down to 3 quick steps for the user. We also created a user-friendly readme file that includes screenshots of the code implementation.
To examine the ease of use and time to implement the new scripts, we tested each of them on 7 users who had different levels of familiarity with programming and neuroimaging (novice users (no programming experience), moderate users (basic-to-intermediate programming experience), and expert users (extensive programming)). To explore additional factors relating to implementation, two of the expert users had to use the scripts in a different environment (e.g., organize the data, install the software, etc.).

Results/Discussion
Overall, moderate and expert level users found the scripts extremely easy to implement and required less than 25 minutes to get all three scripts running (excluding the run time of each script; see Table 6 for individual results). The two novice users required greater support to understand basic elements (e.g., what is a terminal), but with support, were able to complete all the steps in less than 1 hour. Finally, the expert users who implemented the scripts on their own environment found the most time-consuming steps to be installing and troubleshooting Freesurfer (e.g., install errors; troubleshooting a conflict between the preset Freesurfer subjects directory and the output directory required by the scripts) and reorganizing data into a format for the scripts (e.g., putting the data into an organized format with main_folder/subject_folder/subject.nii.gz). Once these steps were complete, each expert user reported about 10 minutes for script implementation. The wrapper scripts made the implementation of the ENIGMA protocols quick and feasible even for novice users. However, there were still three main barriers to participation that required significant time, computational resources, and some expertise: 1) data organization (depending on previous data structure), 2) running freesurfer (~12 hrs/subj), and 3) installation of the required software (e.g., Freesurfer, FSL, R). Future projects may look at ways to streamline these areas for a more seamless user experience in order to facilitate greater sharing of clinical neuroimaging data through ENIGMA.
Availability of supporting data More information about this project can be found at: https://github.com/npnl/ENIGMA-Wrapper-Scripts. A test dataset is available on request; if interested, please email npnl@usc.edu.

Competing interests
None.
Author's contributions EK, JA, and S-LL wrote the wrapper scripts. NJ and PT developed the original ENIGMA protocols and provide guidance/support for ENIGMA working groups. MB, JA, and S-LL tested and edited the wrapper scripts. All authors contributed to the creation of the manuscript.

Introduction
The human cerebral cortex, whether tracing it through phylogeny or ontogeny, emerges through expansion and progressive differentiation into larger and more diverse areas. While current methodologies address this analytically by characterizing local cortical expansion in the form of surface area [1] several lines of research have proposed that the cortex in fact expands along trajectories from primordial anchor areas [2,3] and furthermore, that the distance along the cortical surface is informative regarding cortical differentiation [4]. We sought to investigate the geometric relationships that arise in the cortex based on expansion from such origin points. Towards this aim, we developed a Python package for measuring the geodesic distance along the cortical surface that restricts shortest paths from passing through nodes of non-cortical areas such as the non-cortical portions of the surface mesh described as the "medial wall'.

Approach
The calculation of geodesic distance along a mesh surface is based in the cumulative distance of the shortest path between two points. The first challenge that arises is the sensitivity of the calculation to the resolution of the mesh: the coarser mesh, the longer the shortest path may be, as the distance becomes progressively less direct. This problem has been previously addressed and subsequently implemented in the Python package gdist [https://pypi.python.org/pypi/ gdist/], which calculates the exact geodesic distance along a mesh by subdividing the shortest path until a straight line along the cortex is approximated [5] The second challenge, for which there was no prefabricated solution, was ensuring that the shortest path only traverses territory within the cortex proper, avoiding shortcuts through non-cortical areas included in the surface meshmost prominently, the non-cortical portions along the medial wall. Were the shortest paths between two nodes to traverse non-cortical regions, the distance between nodes would be artificially decreased, which would have artifactual impact on the interpretation of results. This concern would be especially relevent to the 'zones analysis' described below, where the boundaries between regions would be altered. It was therefore necessary to remove mesh nodes prior to calculating the exact geodesic, which requires reconstructing the mesh and assigning the respective new node indices for any seed regions-of-interest. Finally, to facilitate applications to neuroscience research questions, we enabled the loading and visualization of data from commonly used formats such as FreeSurfer and the Human Connectome Project (HCP). A Nipype pipeline for group-level batch processing has also been made available [6]. The pipeline is wrapped in a command-line interface and allows for straightforward distance calculations of entire FreeSurfer-preprocessed datasets. Group-level data are stored as CSV files for each requested mesh resolution, source label and hemisphere, facilitating further statistical analyses.

Results
The resultant package, SurfDist, achieves the aforementioned goals of faciliating the calculation of exact geodesic distance on the cortical surface. We present here the distance measures from the central and calcarine sulci labels on the FreeSurfer native surfaces (Fig. 14b).
The distance measure provides a means to parcellate the cortex using the surface geometry. Towards that aim, we also implement a 'zones analysis' , which constructs a Voronoi diagram, establishing partitions based on the greater proximity to a set of label nodes (Fig. 14c). Surface rendering of the results draws from plotting functions as implemented in Nilearn [7] and exclusively relies on the common library matplotlib to minimize dependencies. The visualization applies sensible defaults but can flexibly be adapted to different views, colormaps and thresholds as well as shadowing using a sulcal depth map.

Conclusions
The SurfDist package is designed to enable investigation of intrinisic geometric properties of the cerebral cortex based on geodesic distance measures. Towards the aim of enabling applications specific to neuroimaging-based research question, we have designed the package to facilitate analysis and visualization of geodesic distance metrics using standard cortical surface meshes.
Availability of supporting data More information about this project can be found at: http://github. com/margulies/surfdist

Introduction
Cloud computing resources, such as Amazon Web Services (AWS) [http://aws.amazon.com], provide pay-as-you-go access to highperformance computer resources and dependable data storage solutions for performing large scale analyses of neuroimaging data [1]. These are particularly attractive for researchers at small universities and in developing countries who lack the wherewithal to maintain their own high performance computing systems. The objective of this project is to upload data from the 1000 Functional Connectomes Project (FCP) [2] and International Neuroimaging Datasharing Initiatives (INDI) [3] grass-roots data sharing initiatives into a Public S3 Bucket that has been generously provided by AWS. This will make the data more quickly accessible for AWS-based analysis of these data, but will also improve the speed and availability of access to this data for analyses performed outside of the cloud. To begin with, we focused on the following collections: The autism brain imaging data exchange The Enhanced Nathan Kline Institute -Rockland Sample (ENKI-RS) consists of structural MRI, resting state functional MRI, diffusion MRI, cerebral blood flow, and a variety of task functional MRI scans and deep phenotyping on over 700 participants from across the lifespan and a variety of phenotypes acquired at a single site [7] The acquisition of this collection is ongoing. . One can connect to the bucket using the configuration shown in Fig. 15. The data is structured as follows: bucketname/data/Projects/ProjectName/Data-Type. For example you can access raw data from the ENKI-RS, as shown in Fig. 15, by specifying the following path in CyberDuck: https:// s3.amazon.com/fcp-indi/data/Projects/RocklandSample/RawData Conclusions Uploading data shared through the FCP and INDI initiatives improves its accessibility for cloud-based and local computation. Future efforts for this project will include uploading the remainder of the FCP and INDI data and organizing the data in the new brain imaging data structure (BIDS) format [10].
Availability of supporting data More information about this project can be found at: https://github. com/DaveOC90/INDI-Organization-Scripts

Competing interests
None.
Author's contributions DO performed quality control, and uploaded the data. DJC wrote code to interact with AWS, preprocessed and uploaded data. MPM and RCC lead the data collection and sharing projects. All of the authors contributed to writing the project report.

Introduction
Task-based fMRI is a powerful approach to understand brain processes for a certain task. However, fMRI images are usually preprocessed hours, days or even months after the scan. During the functional image preprocessing stage, defects in images are detected and, in some cases, cannot be corrected. For example, technical problems with the scanner or lack of collaboration from the subject to perform the given tasks. For these cases it is necessary to realize a new scan. In order to mitigate lost scans due to patient non-compliance, we need an approach to detect such noncompliance during the scan.

Approach
In this Brainhack project, we aim to detect if a subject is following the given task and provide an almost real-time feedback to the researchers to make a decision during the exam if the subject is not collaborating. This is necessary to be performed in order to avoid loss of data, in which the images are typically processed and quality assessed at another day. We will focus on task where there are no button responses from the subject, hence relying solely in the BOLD signal if the subject is collaborating. To do so, we use plan abandonment techniques [1] a sub-area of Artificial Intelligence. For a given fMRI paradigm, a plan should be created and compared with the subject's brain activation during the scan using recognition methods. To use plan abandonment techniques, we need to discretize and formalize the fMRI and construct a expected plan based on the hypothesized paradigm using this formalization. To evaluate the compliance with a specific paradigm, we aim to use real-time fMRI methods to retrieve BOLD signals of brain regions that are supposed to be active in a particular time range. In order to tolerate fluctuations of the BOLD signal, we aim to use the methods that detect non-compliance using a threshold from the expected activation.By doing so, it is possible to detect if a subject is following the paradigm given a specific stimulus type, such as visual or auditory stimulus. The brain state of each stimulus type will be mapped based on atlas from the literature. For example, to cover motor activations,

Fig. 15 (abstract A18). Connecting to the data repository
Brodmann area 4 will be mapped with a state motor_actv. Thus, for a paradigm that works with motor tasks, the plan must contain motor_actv for the given time that the task occurs.

Discussion
The formalization of brain states strongly depends on the discretization of specific region states, which might vary from subject to subject. In order to normalize the signals, a previous tuning phase is required with simple paradigms, depending on which paradigm will be executed. During the scan, an online normalization must be made to a standard space, such as the MNI brain space. This realtime processing is required to map expected active regions to the previously selected brain areas from an atlas. The usage of real-time fMRI methods aggregates to our approach since the tuning and pursuance recognition can be made during the exam. Such real-time fMRI methods can also monitor movements during the scan in order to identify if there is too much subject movement. In the case of fMRI paradigm abandonment, the paradigm can be adapted to induce or interest the subject in a way that the subject proceeds with its tasks, using methods such as demonstrated by [2]. Neurofeedback can be used to sustain the subject's interest by letting the paradigm be more challenging, requiring more attention and collaboration from the patient, such as the paradigm from [3].

Conclusions
This project is in its initial phase. Real-time fMRI methods are being tested, using AFNI's provided tools. In order to use plan abandonment techniques, the next step is to formalize basic stimuli types based on mapped regions. By using these formalizations, paradigms can be converted to a problem of plan abandonment and it becomes possible to evaluate the participation of a subject during the scan.
Availability of supporting data More information about this project can be found at: https://github. com/brainhack-poa/fmri-plan-recongnition.

Introduction
Self-organization is a fundamental property of complex systems, describing the order spontaneously arising by the local interactions of the system components not mediated by top-down inputs. Though, self-organizing systems typically possess a large number of components and exhibit complex dynamics, their evolution is deterministic and governed by a small number of order parameters. This property was used to model the self-organization of the ocular dominance columns of the striate cortex in patterns of neighboring stripes [1] which respond preferentially to inputs from the left or the right eye.
In this model the self-organization across ocular dominance and orientation preference layers was coupled, were both layers were modeled with the Swift-Hohenberg eq. [2] We reduce the model complexity by including only the cortical dominance layer and investigate the parameter dependency of the self-organization with a Matlab implementation.

Approach
The Swift-Hohenberg eq. [2] was used to model the self-organization of the ocular dominance columns. There are two order parameters in this equation, the first one determines the spatial wavelength (λ) of the stripes and the second one the branchiness (ε) of the pattern. is the Laplace operator. The

Conclusions
A simple model suffices to study basic properties of ocular dominance self-organization. Possibly, a combination of models for selforganization in neighboring cortical layers would allow to investigate even higher organizational principles of the cortex [1] e.g.~the coordination between ocular dominance layers, orientation layers, and cytochrome oxidase.
Availability of supporting data More information about this project can be found at: http://brainhack.org/self-organization-and-brain-function. Further data and files supporting this project are hosted in the GigaScience repository: https://github.com/Brainhack-Proceedings-2015/Pfan_HBM_SOBF.

Introduction
Sharing of brain research can be aided by the Neuroimaging Data Model (NIDM) [1][2][3]. NIDM provides a community-based framework for developing data exchange standards that describe the primary observations, computational workflows, and derived results of neuroimaging studies [4]. For example, a researcher sharing a statistical brain map could include with the brain map a data structure, "NIDM Results", that contains complete information about the parameters used to generate the result, significant coordinate points in the brain map paired with test criteria, along with other meta-data exported from the software that generated it. This additional information cannot be represented in the brain map itself, and provides a complete description of the result that can be compared to other results, or used to reproduce it. While work is underway to integrate NIDM into the software used by the human brain mapping community, only low-level tools are currently available to access and query NIDM documents that rely on a graph-based representation called the Resource Description Framework (RDF) [5]. Further, technologies like RDF and the corresponding query language, SPARQL [6] pose a steep learning curve for users of standard Web development workflows. With the recent migration of tools for neuroimaging meta analysis [7,8], sharing [9][10][11][12][13][14][15][16][17], and visualization [18][19][20] into the Web browser, Web developers will be incentivized by the ability to easily integrate brain data into Web applications using familiar languages and formats.  [25] or cloud platforms that provide Python accessibility [26,27]. A schematic of the tool is provided in (Fig. 17). to statistical brain maps from common software [29] into NeuroVault.

Results
A nidm-viewer [https://github.com/vsoch/nidmviewer] that runs queries over the nidm-results can then parse the coordinates and statistical parameters associated with significant locations of activations to be rendered in a table alongside a visualization of the brain map itself (Fig. 18 and example [http://neurovault.org/collections/ 877/fsl_course_av.nidm]). The raw data and parameters of the analysis are thus immediately available for sharing and publication, programatically accessible, and viewed from any web browser.

Conclusions
By providing tools to integrate the NIDM standard into modern web technology, NIDM can be more easily deployed into applications to empower neuroimaging researchers to explore and synthesize results, workflows, and experiments. This application will be extended to return more modern and desired outputs such as images and interactive graphs [30] and additional functionality will be added as the NIDM experiment, workflows, and results standards are further developed. The software and queries are both publicly available [https://github.com/incf-nidash] and open to contributions.

Introduction
The amount of data acquired for an fMRI experiment dimension wise is very large and a challenge for neuroscience studies, in particular for data analysis and visualization. Diverse tools have been developed to confront these challenges, but their analytical results can differ. Addressing those differences is not facilitated by existing tools. The goal of this Brainhack project was to build a flexible utility to analyze fMRI experimental results. This utility is called NeuroView. NeuroView allows researchers to extend the visualizations to their context: every visual behavior or interactions of this tool is customizable. We implemented NeuroView to work in Web-browsers, using JavaScript and the libraries D3.js and jQuery.

Results
We created three tools using NeuroView to best analyze our research results: CC200 search, SVM coefficients and Connectivity matrix. Each tool is used to aid the analysis of results in Machine Learning tasks. Each of these tools is described below in detail.

CC200 search
In this tool, we allow the user to find atlas regions (e.g. Left Putamen from Harvard-Oxford subcortical structural atlas) mapped to a specific parcellation. As as initial approach, the CC200 [1] parcellation method was used, since our analysis uses data from functional MRI. Since we parcellate our data into CC200's ROIs in most of our studies, the identification of atlas regions became necessary to compare with results found in the literature. The search can be performed in two manners: it is possible to search for an atlas region (e.g. Putamen) and retrieve which parcels are included in this region, and it is possible to click an ROI in NeuroView to retrieve which atlas regions include the specific parcel.

SVM coefficients
For the second tool, we created a user interface to identify the ROIs that contribute to the classification in a Support Vector Machine. The classification method uses task-based fMRI features to identify good and poor readers [2] Given a list of most relevant features, as shown in Fig. 19, we can show the features' parcel in NeuroView and identify to which atlas regions this parcel belongs to.

Connectivity matrix
In the third study case, NeuroView was customized to interact with a connectivity chord plot (or connectogram) [3] This plot contains each CC200 parcel and chords that represent the connectivity between these parcels. Since we use the connectivity matrix as features for our deep learning method, we need to check which feature (i.e. the correlation between two parcels) most contributes to the classification. After thresholding 17995 features, we retrieve ten features that are more relevant in our analysis, as shown in Fig. 20. In the chord plot, a red chord indicates that two regions are correlated, and a blue chord indicates that two regions are anti-correlated. By clicking a chord, Neuro-View highlights the regions that are connected by this chord. Thus, highlighted regions are correlated (or anti-correlated) given the chord color. Conclusion This is an initial version of a browser-based neuroimage viewer. The main focus is to develop an embeddable viewer, instead of a standalone desktop software. By doing so, research results can be presented on interactive views, enriching their analysis and interpretation. In our case study, NeuroView facilitates quick evaluation of features for machine learning algorithms, and promotes discussion about them, since the results will inform researchers about their data.
In future work, we aim to directly load Nifti images at client-side and support some AFNI features, such as voxel clustering.
Availability of supporting data More information about this project can be found at: https://github.com/lsa-pucrs/neuroview Introduction DMRI is used for creating visual representations of the structural connectivity of the brain, also known as tractography. Research has shown that using a tissue classifier can be of great benefit to create more accurate representations of the underlying connections [1] The aim of this project was to implement an image segmentation algorithm in DIPY [2] for classifying the different tissue types of the brain using structural T1 weighted images (T1-w) and diffusion MRI images (dMRI), and to incorporate the resulting tissue probability maps for Anatomically-Constrained Tractography (ACT) [3] We used Diffusion Power Maps (DPMs), which are scalar maps that are calculated from dMRI data and have a tissue contrast similar to the T1-w. By performing the tissue classification on dMRI derived scalar maps, the T1-w to dMRI registration step can be avoided.

Approach
We used a Bayesian approach for the segmentation in a similar fashion than the methods proposed in [4] and [5] by applying the Maximum-A-Posteriori (MAP) procedure. The prior probability was modeled with Markov Random Fields (MRF). The MRF distribution was modeled as a Gibbs distribution. We used the Expectation Maximization (EM) algorithm to update the tissue labels at each site and to update the parameters of the log-likelihood in all iterations.

Results
The first row of Fig. 21 shows the tissue classification on T1-w, the initial segmentation based on maximum likelihood and the final segmentation after 10 iterations and beta=0.1. Beta determines the weight of the neighborhood in the MRF model. These two parameters were tuned and validated by permuting 42 different combinations and calculating the Jaccard index between the segmentation of the proposed method against manually segmented brains from the IBSR dataset [http://www.nitrc.org/projects/ibsr]. The second row of Fig. 21 shows the probability maps of the three main tissue classes of the brain. The top row of Fig. 22 shows on the left the Diffusion Power Map (DPM), followed by its tissue classification and the streamlines from the corpus callosum reconstructed with ACT. The bottom row of Fig. 22 shows the tissue probability maps of the segmentation performed on a DPM.

Conclusions
We developed a segmentation algorithm based on a Bayesian framework by using the MAP-MRF approach and EM. The algorithm was tested on T1-w as well as on DPMs [6] The tissue specific probability maps from both the T1-w and the DPMs were then used for ACT. We were able to successfully run ACT with the tissue probability maps derived from the DPMs.

Availability of Supporting Data
More information about this project can be found at: https://github.com/villalonreina/dipy/tree/pve