Tell us what works and what could be better. We read every submission.
@akeshavan·112 public vizzes
This config file defines the settings for a citizen-science web app called appstract, which uses swipes to help scientists annotate PubMed abstracts. The app displays a game where users classify abstracts matching the query “autism AND neuroimaging,” retrieving article text via the NCBI eutils efetch API. It implements a gamified progression system with six levels, each tied to a point threshold and represented by an OpenMoji animal icon. The configuration specifies Firebase credentials for data storage, tutorial settings, and image assets for the home, play, and chat interfaces.
This notebook fetches PubMed abstracts for a list of autism MRI research paper IDs, then writes each abstract to a separate JSON file along with metadata. It uses pandas to read the CSV of PMIDs, requests and untangle to query the NCBI E-utilities API and parse the XML responses, and simplejson to serialize the output. The code also creates a manifest file mapping each PMID to its index and query string.
This visualization compiles a scientific paper layout from a plain-text order file, rendering a table of HTML figure names and paths. The notebook reads the layout with pandas, parses a BibTeX bibliography using bibtexparser with unicode conversion, and prints extracted DOI identifiers from cited references. It organizes the paper’s components—abstract, figures, and HTML sections—into a structured sequence for further assembly. The code relies on pandas for tabular data handling and IPython’s HTML display to preview the ordering.
This example demonstrates a pipeline for predicting brain data quality using deep learning models, applied to 2D slices extracted from a 3D neuroimaging file. It shows how a URL to a `.nii.gz` file is sent to an OpenFaaS serverless function, which generates and returns image slices that are then processed for display. The code uses Python libraries including Matplotlib, PIL, NumPy, and Requests, converting base64-encoded slices into grayscale images and visualizing them side by side. The visualization highlights the workflow of fetching remote brain imaging data and rendering its 2D projections for quality inspection.
This example demonstrates a deep learning workflow for classifying brain images using TensorFlow and Keras. It loads CSV data from the braindr dataset, displaying a pandas DataFrame with vote counts, rater identities, and mean ratings for each image. The code builds a convolutional neural network with layers like Conv2D, MaxPooling2D, Dropout, and LeakyReLU, using Keras' Sequential API. It configures the model for GPU execution, imports optimizers such as RMSprop and Adam, and prepares callbacks like ModelCheckpoint for training.
This visualization compares MRIQC automated quality metrics with manual voting results for T1-weighted brain scans. It processes JSON vote data from multiple raters, consolidating their quality assessments into a pandas DataFrame. The example demonstrates how to aggregate and inspect manual quality-control annotations alongside automated MRIQC scores, using pandas for data manipulation and matplotlib for inline plotting in a Jupyter notebook.
This example demonstrates data augmentation for a convolutional neural network that classifies stroke-related images into two categories. It trains a Keras Sequential model with Conv2D, MaxPooling2D, Dropout, and LeakyReLU layers, using an ImageDataGenerator to apply shear, zoom, and horizontal flip transformations to grayscale images. The code also uses a ModelCheckpoint callback to save the best model based on validation accuracy, processing batches of 256x256 images from training and validation directories.
This example prepares and summarizes a dataset of brain MRI slice images. The notebook loads a metadata CSV into a pandas DataFrame and verifies that all referenced image files exist. It then groups the data by subject and slice direction, counting the number of slices for each binary label (0 or 1) with `groupby` and `apply`, before restructuring the result with `unstack`. The output is a cross-tabulated summary showing slice counts per subject, direction, and label.
This notebook builds and trains a convolutional neural network for binary image classification using Keras with TensorFlow. It defines a Sequential model with Conv2D, LeakyReLU, MaxPooling2D, Dropout, Flatten, and Dense layers, then compiles it with categorical crossentropy and the Adam optimizer. The model trains on pre-loaded NumPy arrays from seed-0-train.npz, with validation on seed-0-val.npz, and uses ModelCheckpoint to save the best weights based on validation accuracy.
This example shows a Docker Compose configuration for deploying a serverless function platform using Traefik as a reverse proxy with built-in load balancing, automatic HTTPS via ACME, and a monitoring stack with Prometheus and Alertmanager. The visualization is the orchestration of multiple containerized services—including the gateway, sample functions like webhookstash, hubstats, and nodeinfo—across a Docker Swarm cluster, with Traefik routing traffic based on path prefixes and handling TLS certificates. The accompanying log output displays Traefik's debug-level startup messages, revealing its global configuration details such as entry points, ACME settings, Docker provider in swarm mode, and health check intervals, effectively illustrating how the infrastructure is assembled and monitored.
This visualization demonstrates a synthetic image-segmentation experiment using TensorFlow and Keras, where a binary mask of a filled circle is generated with the skimage.draw.circle function and displayed via matplotlib. The notebook focuses on computing the Hausdorff distance metric between predicted and ground-truth segmentation masks, using Keras backend operations to implement the distance calculation. The visualization shows the input circle image as a matplotlib axes image, illustrating how the metric is applied to evaluate segmentation quality. The code imports TensorFlow, NumPy, Keras backend, and matplotlib inline, establishing a workflow for comparing segmentation outputs against reference shapes.
This notebook demonstrates a TensorFlow/Keras implementation of the Hausdorff distance metric, visualized with synthetic image data. It uses `skimage.draw.circle` to generate a ground-truth circle image, then computes and displays the Hausdorff distance between predicted and actual binary masks via matplotlib. The visualization includes an inline image plot of the mask, rendered as an interactive matplotlib axes image, alongside the execution of the metric computation within the Keras backend.
A force-directed graph visualization displays a network of brain connectivity nodes, where each node represents a region labeled with hierarchical identifiers and edges are weighted by correlation values. The graph uses a circular layout with curved links connecting nodes, with edge thickness and color mapping to the numerical weights, which include both positive and negative correlations. The visualization, titled "DMN connectogram," is designed to show the default mode network connectivity patterns, with nodes positioned around a circle and linked by curved bezier edges that encode connection strength. Node sizes vary based on their degree of connectivity, and the layout emphasizes the modular structure of the network through spatial grouping. The negative weights (e.g., -1.46, -2.46) suggest inhibitory or anticorrelated connections, while positive weights indicate excitatory links, providing a comprehensive view of the network's functional architecture.
An interactive 3D volume rendering of structural MRI brain data, created with IPyvolume and its pylab interface. The notebook loads NIfTI images via nibabel, first displaying a defaced scan with translucent opacity levels, then a full T1-weighted image from OSF. The visualization uses `p3.figure` to configure camera properties, hide axes and box, and set coordinate limits, with `p3.volshow` rendering the volume. Users can rotate and inspect the brain in three dimensions through the Jupyter widget.
This example visualizes hierarchical clustering of a brain connectivity graph using a force-directed layout. It loads a Desikan parcellation graph from a GraphML file, computes linkage clusters with scipy’s `linkage` and `fcluster`, and encodes cluster memberships at six levels into node names. The interactive rendering, embedded via an iframe from CodePen, uses d3.forceSimulation to display the nodes and their connections, with node sizes reflecting connection counts and names combining cluster labels and anatomical region names.
This visualization displays a brain connectivity network as a node-link diagram, where each node represents a cortical region labeled with Desikan-Killiany atlas terminology (e.g., lh-bankssts, rh-precentral) and sized by its import count. Edges connect regions based on structural connections, with the layout revealing clusters of functionally related brain areas. The visualization uses a hierarchical naming convention to organize regions by hemisphere and lobe, with connection strengths implied by the size values shown in the JSON data. The interactive graph allows exploration of the brain's structural connectivity patterns across 68 cortical regions.
A force-directed graph visualizes module dependencies from brain imaging data, where each node represents a cortical region and links show import relationships. The network is computed using a force layout, with node size encoding degree (module size) and colors distinguishing different anatomical lobes. Hovering highlights connections, and the graph can be explored interactively to reveal the hierarchical structure of brain connectivity.
This visualization shows the dependency structure of a JavaScript module (a1.b1.c1.d1.e2.f2.n0) and its 61 related modules, rendered as a directed graph with nodes sized by their import counts and edges representing dependency relationships. The data comes from a DWI (diffusion-weighted imaging) analysis workflow, with module names encoded hierarchically. The graph uses a force-directed layout, with each node sized according to its number of imports and connected by directed edges showing dependencies, revealing clusters of tightly interconnected modules and central hub nodes.
This visualization is a force-directed graph showing the modular structure of brain connectivity data from a diffusion-weighted imaging (DWI) session. The JSON file describes nodes (brain regions) and their directed connections, encoded using hierarchical identifiers that group regions into modules. Node size represents degree (number of connections), and the network layout arranges nodes spatially to reveal clusters of densely interconnected regions. The graph emphasizes the modular organization of brain connectivity, with module membership visually separable by the hierarchical naming pattern and connection density.
A scatter plot displays four data points with x-values ranging from 0.5 to 2.9 and y-values from 5.2 to 20. The example uses D3.js version 4.10 to create an SVG visualization, employing `d3.scaleLinear` for both axes and `d3.axisBottom` and `d3.axisLeft` to render the tick marks. Margins are defined around the 500x300 pixel plotting area, with axes positioned at the bottom and left edges of the chart. The code demonstrates a basic D3 tutorial setup, showing how to map data values to pixel coordinates and append axis groups to an SVG element.
This example demonstrates a basic scatter plot with axes, built using D3.js version 4.10. The plot displays four data points with x and y coordinates, and the axes are generated using `d3.axisBottom` and `d3.axisLeft` with linear scales (`d3.scaleLinear`). The code defines helper functions for adding, removing, and randomizing data points, though these are not invoked in the visible script. The SVG rendering is set up with explicit margins and dimensions, and the plot is appended to an element with the ID `scatterArea`. The data is hardcoded as an array of objects, and the visualization is rendered entirely in the browser.
An interactive bar chart demonstrates D3.js data binding and transitions. The visualization renders an array of numeric values as horizontal bars, with buttons to add, remove, or randomize data points. Hovering changes a bar’s color, while clicking enlarges it by 50% with a bounce easing effect. The code uses `d3.select`, `.data()`, `.enter()`, `.exit()`, and chained `.transition().duration(1000)` methods to animate bar widths and opacity. Mouse events (`mouseover`, `mouseout`, `click`) trigger style changes and re-bind updated data, showing dynamic updates in a div-based layout with CSS classes.
Five hardcoded numeric values render as a row of horizontal steel-blue bars using D3’s data join with `<div>` elements. On page load, each bar transitions its width from zero to its data value over one second. Hovering changes a bar’s background to black; clicking triggers a bounce-eased transition that enlarges the bar by 50% and updates the underlying array. The example demonstrates basic D3 v4 selection, `.transition()`, `.duration()`, and event handling with `mouseover`, `mouseout`, and `click`.
This animation demonstrates a D3.js tutorial from Neurohackweek 2017, featuring a simple bar chart visualization with a "Hello World" heading. The page loads d3.min.js v4.10.0 and uses CSS-styled bars with steelblue backgrounds, white text, and right-aligned labels. The visualization renders as a static bar chart without interactive transitions, serving as an introductory example of D3’s data-binding and styling capabilities.
This animated D3.js tutorial from Neurohackweek 2017 demonstrates a simple bar chart visualization. The page renders a series of horizontal steelblue bars with white text labels, built using D3 version 4.10.0. The visualization displays "Hello World" as a header with styled bar elements, using the bar class to apply background colors, margins, and text alignment. The animation is driven by D3's enter/update/exit data join pattern, where the bars respond dynamically to data changes. The code showcases fundamental D3 concepts including data binding, DOM manipulation, and CSS-styled SVG or HTML elements for building interactive visualizations.
A gentle introduction to D3.js for neuroimaging novices, this tutorial walks through creating a basic bar chart with HTML and CSS. The example starts with a "Hello World" heading and builds a simple bar visualization using styled div elements, with steelblue bars and white text labels. It demonstrates core D3 concepts through a minimal, animation-free example, accompanied by the D3 library (v4.10.0) from a gist.
This animated D3.js tutorial demonstrates how to build a simple bar chart with a "Hello World" header. The visualization uses div-based bars with a steelblue background, styled via CSS classes, and likely animates bar heights to illustrate data binding and update patterns. It serves as an introductory example for Neurohackweek 2017, showing basic D3 v4 usage for creating and animating DOM elements with data.
This animation, from a Neurohackweek 2017 tutorial, uses D3.js version 4.10.0 and jQuery 3.2.1. The visualization demonstrates D3's data-binding and transition capabilities by animating elements in response to data changes, leveraging D3's scales, axes, and selection methods to create an interactive and dynamic representation of data.
This example generates image tiles from 3D neuroimaging data, converting MRI volumes into 2D slice images along a specified axis. It loads NIfTI files with nibabel, reorients the data to IPL coordinates, and renders each slice as a grayscale PNG using matplotlib. The code also creates JSON manifests that record slice indices, mask information, and file paths, enabling tile-based visualization of brain scans.
This example visualizes step counts for two subjects across seven hourly time points on a single day, using a small multiples-style line chart. It renders the data from a CSV file with d3.line and d3.scaleTime, mapping hours on the x-axis and step counts on the y-axis, while grouping by subject via d3.group. The chart uses d3.axisBottom and d3.axisLeft for tick marks, with a distinct color for each subject’s line and a legend to identify them. The visualization relies on d3.csv to parse the fake_data.csv source.
This notebook presents an interactive Python crash course that teaches fundamental programming concepts through a Jupyter Notebook interface. It demonstrates variable assignment, data types (floats, booleans, strings), and error handling by showing intentional syntax errors like `5a = 5` alongside working examples. The notebook uses the standard Python interpreter via Jupyter, with markdown cells providing explanatory text and code cells executing live examples that print output or raise errors. The tutorial emphasizes practical usage, including installation instructions for Anaconda and keyboard shortcuts for notebook navigation.
An interactive WebGL visualization displays a partially transparent human brain surface model, rendered in white with a randomized pattern of fully transparent faces that create a mesh-like see-through effect. The scene uses Three.js with the VTKLoader to load a FreeSurfer curvature dataset, applying dual materials—one opaque and one fully transparent—to individual faces. TrackballControls enable rotation, zoom, and panning, while a directional light and stats monitor support the animated 3D exploration.
This example displays a cortical surface mesh from a VTK file using pythreejs, a Jupyter widget library that wraps Three.js. It shows the brain’s left hemisphere pial surface colored by travel depth values, read with `read_vtk` from mindboggle.mio. The code builds a `FaceGeometry` from vertex and face arrays, applies a `LambertMaterial`, and renders the mesh in a `Scene` with `AmbientLight` and a `PerspectiveCamera`. Users can rotate the model interactively via `OrbitControls`.
This example processes brain scan sprite images for use in a web-based visualization. It loads PNG files from a local directory, replaces pure black pixels with white, and then applies histogram equalization and autocontrast using Pillow’s `ImageOps` and `ImageEnhance`. The cleaned images are saved to a new path, with the code iterating over a list of subject IDs read from a text file via `np.genfromtxt`. It reports completion or errors for each subject, demonstrating a batch image-preprocessing pipeline for preparing neuroimaging data.
This visualization evaluates lesion segmentation results by plotting false positives (FP) against false negatives (FN) for each exam. It retrieves subject data from a MongoDB collection, filters entries reviewed by a specific clinician, and aggregates counts of FP and FN annotations into a pandas DataFrame. The notebook uses matplotlib through `%pylab inline` for plotting, with a custom `remove_crap` function to clean chart spines and ticks. Data comes from the `subjects` collection in a local MongoDB instance.
This visualization displays brain imaging results for a single subject, comparing fractional anisotropy (APM), mean diffusivity (MD), and B0 maps before and after a procedure. It automatically locates the world coordinates of the maximum APM difference and generates six static PNG plots, each showing a statistical map overlaid on a pre-APM background. The code uses Nilearn’s `plot_stat_map` and `plot_anat` functions with a jet colormap and black background, alongside NumPy for coordinate transforms and Matplotlib for figure styling.
This notebook demonstrates a neuroimaging workflow that processes anatomical T1 brain images from five subjects in the ABIDE dataset. It uses FSL’s BET to create brain masks, FAST to segment gray matter, white matter, and CSF, and nilearn’s plotting tools to overlay masks and probability maps on the original scans. The code builds a nipype workflow with DataGrabber, DataSink, IdentityInterface, and Function nodes, then runs it iteratively over all subjects and visualizes the workflow graphs.
This notebook demonstrates a Scheme interpreter’s evaluation process, showing how expressions like `(+ 1 2)` and `(+ 1 (* 2 3))` are recursively parsed and reduced. The code uses custom `Pair` and `nil` data structures from `scheme_primitives` and `scheme_reader`, with `scheme_eval` printing each subexpression’s representation and tracing symbol lookups, self-evaluation, and procedure application. Output cells display intermediate results, such as `Pair(3, nil)` after adding 1 and 2, alongside debug print statements that reveal the step-by-step evaluation order. The example highlights the interpreter’s handling of nested combinations and its error-checking via `check_procedure`.
This example visualizes the relationships between multiple MRI scan sessions by computing and plotting the affine and warp transformations needed to align them to a common template. The notebook uses Python with pandas, numpy, and matplotlib, along with custom functions built on nipype’s file management utilities, to load alignment status JSONs and construct transformation dictionaries. It shows how each session’s T1-weighted image can be mapped to any other session through a chain of affine and warp operations, with the resulting paths displayed as a network of connections. The rendering relies on matplotlib’s inline plotting to present the computed transformation graph.
This notebook demonstrates recursive tree algorithms implemented in Python, defining functions to square tree values, compute height, find maximum values, locate paths, prune branches, and generate hailstone sequences. The code uses a custom `tree` representation as nested lists, with helper functions like `root`, `branches`, and `is_leaf` to navigate the structure. Each algorithm follows a consistent pattern of processing the root, checking for leaf nodes, recursing over branches, and returning the final result. The examples illustrate functional decomposition and recursion for hierarchical data manipulation, with no external visualization libraries involved.
This Jupyter notebook demonstrates how to define a curried `multiadder` function in Python, where `multiadder(n)` returns a chain of functions that each accept one argument and accumulate a sum. The code shows two implementations: a first pass using a dummy total variable, and a refined version that returns nested functions to handle the summation. Example calls like `multiadder(5)(1)(1)(1)(1)(1)` output `5`, and `multiadder(2)(4)(5)` returns `9`, illustrating the incremental function-returning behavior. The notebook uses standard Python 2 syntax, with code cells and Markdown explanations, and outputs results directly as text.
This example visualizes brain tractography streamlines using DIPY and VTK, comparing original and rescan fiber tracks side by side in a tabular layout. It loads track data from TRK files with nibabel’s trackvis module, renders each set of streamlines as off-screen VTK images, and converts them to base64-encoded PNGs for inline HTML display. The code also defines helper functions to arrange these images into two- or four-column comparison grids, labeling each column by subject.
The dashboard displays MRI volumes alongside scalar summary metrics, linking clinical or behavioral data to brain images for quality control. Users select subjects by histogram brushing to view corresponding volume slices, annotate findings, and edit voxels directly in the browser. The web app uses Python-generated JSON configurations to define database entries and UI elements, with images referenced as pointers. The notebook embeds the live dashboard via an iframe pointing to a local server, demonstrating modular pipeline integration.
This notebook demonstrates how to convert Mindboggle neuroimaging outputs into a format compatible with Mindcontrol, a web-based visualization tool. It shows the process of generating structured entries that link brain segmentation results, T1-weighted MRI images, and associated metrics for each subject. The code uses Python libraries including pandas for handling demographic data, nipype for JSON file management, and custom functions to extract file paths and create metadata entries. The visualization approach relies on organizing subject-specific data into JSON-ready dictionaries that Mindcontrol can consume for interactive display.
This example shows how to update a MongoDB database with neuroimaging metrics derived from FreeSurfer, using a JSON file as the data source. The notebook loads brain volume measurements and associated demographic metadata, then prepares them for database insertion. It uses pandas for data manipulation, nipype's `load_json` and `save_json` for file handling, and pymongo to interact with the MongoDB collection. The visualization highlights the structure of FreeSurfer-derived brain metrics alongside study-specific metadata fields.
This example visualizes the relationship between imaging-derived connectivity metrics and clinical measures in multiple sclerosis patients by computing global efficiency from weighted brain graphs. The notebook applies PCA to combine multiple imaging features per connection, then calculates efficiency values for each subject using the Brain Connectivity Toolbox (bct.efficiency_wei). The resulting efficiency dataframe is merged with demographic and clinical data using pandas, with Seaborn and matplotlib available for plotting, though the visualization output itself is not displayed.
The visualization displays resting-state fMRI data across seven brain networks, showing how functional connectivity patterns are organized in the brain. It uses a force-directed layout to position nodes representing brain regions, with edges indicating connectivity strength between them. The code relies on numpy and scipy for data processing, while the rendering pipeline employs matplotlib for generating the network plot, with pylab enabling interactive plotting in a Jupyter notebook environment.
The example shows a PCA-based analysis of neuroimaging and clinical data from a multiple sclerosis dataset, displaying how imaging-derived features relate to demographic and clinical variables. It computes principal components from diffusion and magnetization transfer metrics, then explores correlations with clinical measures like EDSS and timed walk. The notebook uses pandas for data handling, scikit-learn's PCA and RandomForestRegressor for modeling, and statsmodels for statistical testing, with seaborn and matplotlib providing visualization support.
This example visualizes the relationship between brain connectivity measures and disability in multiple sclerosis patients. It fits ordinary least squares regression models predicting the EDSS score from diffusion imaging metrics and demographic covariates across each brain connection, then displays the resulting p-values and R-squared values in a table. The code uses pandas for data handling, statsmodels' `ols` API for the regression models, and seaborn with pylab inline for plotting.
This visualization demonstrates signal-to-noise ratio (SNR) calculation from ADNI phantom MRI data using a Jupyter notebook. It loads NIfTI images with nibabel, applies Otsu thresholding and histogram-based binning to segment structures, then labels connected components with scipy.ndimage. The workflow includes FOV validation, quaternion-based RAS coordinate transformation, and voxel volume checks using custom functions like `bin_data` and `clean_labels`, with matplotlib and prettyplotlib used for plotting. The notebook processes phantom scans to identify regions meeting required volume thresholds.
This example demonstrates a minimal Python 2 Jupyter notebook workflow, where a single variable `a` is assigned the integer value 5 in the first code cell. The notebook contains two cells, with the second cell left empty, showing no computation or visualization output. It uses the IPython kernel and Jupyter notebook format to structure the code execution environment, though it does not load any data or render any graphical content. The notebook’s metadata specifies Python 2.7.11 as the runtime, but no libraries or visualization APIs are invoked.
This notebook demonstrates a simple line plot created using matplotlib within an interactive IPython environment. The first cell enables inline plotting with `%pylab`, and the second cell generates a basic line chart, producing a single Line2D object rendered as an inline PNG image. The visualization serves as a minimal example of plotting a line with numpy/matplotlib in a Jupyter notebook.
This notebook demonstrates a machine learning workflow for predicting reading outcomes from demographic and neuroimaging data. It loads a tab-separated dataset containing variables such as age, gender, cognitive scores, and a diffusion MRI measure (L_SLFp_FA), then builds and evaluates classification models using scikit-learn’s ExtraTreesClassifier and LogisticRegressionCV. The code employs a Pipeline with StandardScaler for preprocessing, and uses StratifiedKFold for cross-validation to assess model performance. Visualizations include a dataframe preview rendered as an HTML table via pandas, with the analysis executed in an inline matplotlib environment using seaborn for styling.
This example visualizes brain connectivity by computing a streamline connectivity matrix from diffusion tractography data. The notebook uses DIPY’s `utils.connectivity_matrix` to map streamlines to cortical and deep gray matter regions, then writes the resulting metric matrices to CSV files. It loads track-vis streamlines and FreeSurfer-labeled anatomical images with nibabel, applies a voxel-to-world affine transformation, and reduces labels to relevant gray matter regions. The code also demonstrates how to filter streamlines for specific functional regions using custom region maps, and relies on FSL and FreeSurfer tools for image processing.
This visualization displays electrode voltage data from an experiment, with multiple electrode readings plotted over time and separated by side (Right/Left). The notebook uses pandas to organize the data, matplotlib for plotting, and mpld3’s `enable_notebook` to render the figure interactively in a Jupyter environment. A custom `ClickInfo` plugin registers a mousedown handler on the plotted points, triggering an alert with the point index. Seaborn is imported for styling, and the code includes a table of electrode measurements for reference.
This visualization demonstrates the relationship between brain scan variables and subject metadata across a multi-site study. It uses pandas for data loading, seaborn for statistical plotting, and matplotlib for inline rendering within a Jupyter notebook. The code reads a FreeSurfer CSV dataset, applies LeaveOneOut cross-validation from scikit-learn, and fits models with statsmodels formula API. It displays sample rows of the dataframe to show the structure of the neuroimaging data.
This example visualizes statistical power analysis for multisite neuroimaging studies, plotting curves that show how power varies with different parameters like effect size, sample size, and number of sites. The notebook uses Python with `%pylab inline`, seaborn for styling, and custom functions from `euro.stats` such as `power_solver` and `get_power` to compute power values. It also integrates R via `rpy2` for statistical functions, and uses pandas DataFrames and NumPy arrays to handle data and generate the curves.
This visualization demonstrates the variability of FreeSurfer-derived brain structure measurements across different MRI scanner models and sites. It plots the volume values for anatomical regions like the lateral ventricle and cerebellum, revealing distribution patterns and potential batch effects. Built with a Vue framework, the notebook uses pandas for data manipulation, matplotlib and seaborn for statistical plotting, and processes a CSV file containing subject-level neuroimaging metrics. The display emphasizes comparative analysis of brain region volumes across scanning conditions.
This visualization simulates longitudinal brain-imaging measurements across multiple subjects and time points, showing how percentile values (e.g., MTR_25) vary and are modeled with ordinary least squares regression per subject. It first computes subject means, average standard deviations, and true beta coefficients from the input CSV, then generates synthetic data for three time points using normal distributions. The code relies on pandas for data manipulation, statsmodels formula API for OLS fitting, numpy for random sampling, and seaborn for plotting.
This visualization displays correlation plots of spinal cord measurements from a multiple sclerosis dataset, including metrics like cord area, gray matter, and white matter at different spinal levels, alongside clinical scores (EDSS). The analysis uses pandas to load the data and seaborn to generate the plots, with a white background, Set1 color palette, and talk-context styling. Dark red and dark blue colors distinguish the plots, which examine relationships between structural measurements and disability scores.
This notebook analyzes FreeSurfer metrics from a brewery database, focusing on EUROTRIP study subjects. It melts the dataframe to iterate over variables and visualizes scanner and institution distributions using pandas and matplotlib’s inline plotting. The code filters by study tag, extracts sequence identifiers from subject IDs, and uses statsmodels for potential statistical modeling. It demonstrates a data-cleaning and exploratory workflow for neuroimaging quality metrics.
This example visualizes functional connectivity between brain regions by computing and displaying Pearson correlation matrices from resting-state fMRI time series. The notebook loads parcellated time-course data for multiple subjects, maps region names from summary statistics files, and uses pandas `DataFrame.corr()` to generate correlation matrices. It then renders the matrices as tabular heatmaps with Matplotlib’s inline plotting, showing pairwise connectivity strengths across cortical and subcortical regions.
The notebook explores resting-state EPIC data by loading subcortical time-series from a CSV file into a pandas DataFrame, displaying the first rows to inspect voxel-level signal values alongside spatial coordinates. It uses `pd.read_csv` to parse the tabular file, which contains columns for voxel labels and time points, and `%pylab inline` to enable matplotlib plotting within the notebook. The description highlights raw time-series data before any averaging or smoothing, showing the initial structure of the dataset for a single subject.
This visualization shows how the regression coefficients for cortical white matter volume vary across different MRI scanner sites. Using pandas and statsmodels, it fits a linear model of cortical white matter against age for each scanner group, then displays the mean beta values and standard errors in a coefficient plot generated by seaborn's `coefplot` function, alongside a summary table of the across-site variability.
This example uses pandas and Matplotlib within an IPython notebook to aggregate and compare FreeSurfer brain segmentation statistics across multiple CSV files. It processes volume, area, thickness, and aseg measurements, grouping them by subject ID and averaging values to produce normalized and unnormalized output tables. The code merges separate CSV files, collapses left/right hemisphere labels into combined metrics, and then saves the resulting aggregated data for each measurement type.
This notebook analyzes longitudinal brain-imaging data by parsing SIENA reports from multiple scanner types (GE, Ph, Si) across time points. It shows summary statistics of percentage brain volume change (PBVC), including mean, standard deviation, and root mean squared deviation, grouped by scanner in a Pandas DataFrame. The code uses glob to collect report files, pandas for data aggregation, and NumPy for norm calculations. It also gathers associated GIF/PNG images for a quality-check webpage, though the visualization itself is primarily tabular statistical output.
This visualization shows how brain tissue volumes (CSF, WM, GM, and total brain) change across multiple time points and scanner types, with each subject’s measurements pivoted into a comparative table. The code uses pandas for data wrangling, including `pivot_table` and column aggregation, and relies on `seaborn` and matplotlib’s `%pylab inline` for plotting. Data comes from SIENAX report files parsed into a DataFrame, then normalized to cubic centimeters. The final table displays time point and scanner metadata alongside the computed tissue volumes.
This example visualizes longitudinal FreeSurfer brain imaging data, showing how CSF, white matter, gray matter, and cortical thickness change over time and across different scanners. The code uses pandas to aggregate tissue volumes from the asegstats tables, merges thickness measurements from left and right hemisphere parcellations, and displays the resulting dataframe. Seaborn and matplotlib inline plotting are imported for potential statistical visualization, while statsmodels formulas are available for regression analysis of the tissue metrics.
This example visualizes longitudinal Freesurfer brain imaging data, showing how volumes of cerebrospinal fluid, white matter, gray matter, and whole brain, along with mean cortical thickness, change across time points and scanner types. The code loads CSV tables into pandas DataFrames, aggregates specific anatomical regions into tissue categories, and merges hemisphere thickness values. It uses matplotlib, seaborn, and statsmodels for plotting and statistical modeling, with the data prepared through pandas operations before visualization.
This notebook demonstrates Python string formatting through a series of interactive code cells. It shows how variables like `animal`, `verb`, and `noun` are assigned values and then inserted into template sentences using the `.format()` method from the Python standard library. The examples progress from simple variable printing with `print` statements to building sentences with placeholders like `{noun}` and `{verb}`, which are replaced with actual values, including numbers, demonstrating flexible substitution. The notebook uses standard Python 3 syntax and pandas for data handling, with matplotlib inline plotting enabled for visualization context.
The visualization compares brain structure volumes across subjects before and after a software upgrade, using pandas to load, merge, and reshape CSV data from cortical and subcortical parcellation files. It calculates coefficients of variation per subject and region, then computes percentage volume changes relative to a reference measurement, isolating specific regions of interest for display. The code relies on pandas operations such as `pd.melt`, `pivot_table`, and `groupby` with lambda functions to structure the data for plotting.
This visualization presents statistical calculations for brain imaging data, comparing reliability metrics across different analysis methods. The notebook uses Python with rpy2 to bridge R and Python, calling the `psych` package for intraclass correlation coefficients and `statsmodels` for additional statistical modeling. It generates plots with matplotlib and seaborn, applying custom chart-cleaning functions to remove unnecessary axes and gridlines. The code also leverages pandas for data manipulation and NumPy for z-score normalization, with output rendered inline through IPython’s `%pylab` magic.
This example demonstrates how to construct and execute a simple Nipype workflow using the pipeline engine. It defines a Python function node that passes inputs through unchanged, connects it to an identity node with iterable parameters, and runs the workflow serially. The visualization shows the workflow's execution log, tracking how multiple parameter combinations (input1 values 1–7 and input2 values 5–9) trigger separate function node runs in distinct output directories. The code uses Nipype's `pe.Workflow`, `pe.Node`, `Function`, and `IdentityInterface` APIs to manage the dataflow.
This visualization displays resting-state functional connectivity among 18 subdivisions of the left and right precentral motor cortex, rendered as a circular connectome with node angles arranged by hemisphere. It shows both inflated brain surface labels color-coded by subdivision and a connectivity circle plotting pairwise correlations from CSV connectome data. The code uses PySurfer’s `Brain` for surface rendering, MNE’s `plot_connectivity_circle` with `circular_layout` for the network diagram, and seaborn’s `blend_palette` to generate node and edge colormaps, with Matplotlib’s `GridSpec` composing the multi-panel figure.
The example uses a Jupyter notebook with Python to perform leave-one-out cross-validation and permutation testing for partial least squares (PLS) regression models. It defines a PRESS score function and a grid search to select the optimal number of components, then shuffles the response variable to generate a null distribution of PRESS scores. The code relies on scikit-learn's `PLSRegression`, `LeaveOneOut`, and `cross_validation` modules, along with NumPy and SciPy for statistical calculations, to estimate a p-value for the model's predictive performance.
This example demonstrates fitting a Gaussian mixture model to multidimensional data using the expectation-maximization (EM) algorithm. It shows how the model estimates means, standard deviations, and mixture proportions for each dimension of the dataset. The code uses pandas to read the CSV file, NumPy for numerical operations, and matplotlib for inline plotting. It applies the EM algorithm separately to each column of the data, then prints the fitted parameters for each dimension.
This Vue-based visualization uses a Jupyter notebook with Python and matplotlib to display an embedded PNG image. The notebook loads inline plotting with `%pylab` and imports `prettyplotlib` for styling. The single visualization is an image file referenced from the user's local filesystem, rendered directly in the notebook output. No interactive or custom Vue components are shown; the example primarily demonstrates embedding a static image within a computational notebook workflow.
This visualization shows the results of a permutation test for a Partial Least Squares (PLS) regression model predicting EDSS scores. It displays two side-by-side kernel density estimate plots of the distribution of $R^2$ values and root mean PRESS values across 1,000 random permutations, with vertical dashed lines marking the observed model performance (R² = 0.1282, rmPRESS = 1.6954). The empirical p-values computed from the permutation distributions are annotated directly on each plot. The chart uses matplotlib and seaborn, removes chartjunk, and displays the density plots with shaded colors, axis labels, and titles for each panel.
This notebook analyzes MRI volumetric reliability and power for a multisite study, showing how between-site reliability and study size affect the ability to detect genetic effects on brain volumes. It uses statsmodels and NumPy for statistical calculations, pandas for data tables, and matplotlib with pylab inline mode to render reliability metrics and power curves. The visualization includes tables of intraclass correlation coefficients and power curve figures for varying site numbers, effect sizes, and reliability thresholds.
This visualization presents a power analysis for a multisite MRI study, showing how the number of sites and between-site reliability affect the ability to detect genetic effects on neuroanatomical volumes. It displays power curves and tables that illustrate the minimum detectable effect sizes and required sample sizes across varying reliability levels. The example uses Vue for the interface and WebGL for rendering, with data derived from the accompanying Jupyter notebook that employs statsmodels and numpy for statistical calculations. The visualization emphasizes the impact of non-standardized imaging protocols on statistical power.
This visualization tracks the misclassification rate of a stochastic gradient descent classifier over 5,000 iterations, with separate lines for training and test datasets. The code uses Python with NumPy, Pandas, and Seaborn’s `color_palette` for styling, while Matplotlib’s `plot` and `legend` functions render the two curves. The y-axis shows misclassification rate and the x-axis shows iteration counter, revealing how the model’s performance evolves during a single pass through the data with a constant step size.
This visualization shows correlations between brain regions from resting-state fMRI data, focusing on subcortical and cortical areas implicated in Parkinson’s disease. It displays pairwise connectivity values as a correlation matrix, computed from FreeSurfer parcellation time series. The code uses Python with pandas for data handling, seaborn for statistical plotting, and matplotlib’s inline mode for rendering. It also employs itertools to generate all region pairs, and NumPy’s genfromtxt for reading the input files, with clinical follow-up data integrated by visit type.
This visualization displays the correlation between resting-state fMRI time series across selected brain regions, represented as a matrix of pairwise connectivity values. It computes Pearson correlations from parcellated signal data, then organizes the resulting edge strengths into a tabular format per subject. The code uses pandas for data manipulation, numpy for numerical operations, and seaborn for potential statistical plotting, with region names drawn from FreeSurfer cortical and subcortical parcellations.
This visualization displays functional connectivity between brain regions as a circular node-link diagram, with edges colored by PLS regression coefficients relating resting-state fMRI correlations to disability scores (EDSS) in multiple sclerosis patients. The code converts correlation values to z-scores via Fisher transform, then applies PLSRegression to extract predictive components. Using MNE-Python’s `circular_layout` and `plot_connectivity_circle`, it arranges region names around a ring, styles nodes with seaborn color palettes, and encodes edge weights through a custom colormap with a colorbar. The underlying data is loaded from a CSV of freesurfer parcellations and connectivity metrics.
A Vue-based visualization of brain MRI segmentation data, this example loads anatomical and labeled brain volumes using nibabel and renders them with nipy's OrthoSlicer. The notebook applies a threshold to isolate specific cortical regions, remaps label values, and displays the result as a colored overlay on the anatomical scan using an HSV colormap, producing a single axial slice visualization of segmented brain structures.
This visualization displays a 16-slice mosaic of brain MRI scans across three orthogonal planes (x, y, z), with yellow contour lines outlining anatomical labels from a segmentation. The code loads NIfTI brain images and masks via nibabel, masks background data with NumPy masked arrays, and uses nipy’s `plot_anat` and `contour_map` to render slices with matplotlib subplots. It computes bounding boxes from the affine transformation to select meaningful cut coordinates, then arranges the slices in 4×4 grids per plane. The function supports optional contouring and saving each mosaic as a PNG image.
This visualization demonstrates a regression analysis workflow from a Julia notebook, showing how a random feature map (phi) transforms 2D samples into a 250-dimensional space for least-squares fitting. The code computes the optimal weight vector w using normal equations with ridge regularization, evaluating the objective function across different lambda values. It uses Julia’s linear algebra operations (`transpose`, `\` for matrix division, `eye`) and `randn` for Gaussian sampling, with SVG rendering and animation to display the fitted model’s error surface and weight trajectories.
This example visualizes the variability of regression coefficients for cortical white matter across different MRI scanner sites. It plots the beta coefficients and standard errors for the intercept and age covariate, summarizing their mean and standard deviation across scanners. The code uses pandas for data manipulation, statsmodels’ `ols` for per-scanner linear regressions, and seaborn’s `coefplot` to render the coefficient comparisons.
This example demonstrates statistical power calculations for several genetic association models (DRAB1_sGMV, HLAB_ucca, HLAB_sGM, NFkb_WM) using R’s noncentral F distribution via the rpy2 interface, with power derived from effect sizes and sample sizes listed in a pandas DataFrame. It imports the `stats` package and uses `statsmodels.api` alongside scipy.stats, defining a custom `pf` function that calls R’s `qf` and `pf` functions to compute critical values and noncentral power. The notebook also loads precomputed intraclass correlation coefficients from a pickled file and displays the power table as an HTML-rendered pandas DataFrame.
This visualization demonstrates white-stripe normalization of a T1-weighted brain MRI, overlaying a colored white-stripe mask on the normalized anatomical image. The notebook imports nipy’s `plot_map` for rendering, and uses scikit-image’s `threshold_otsu` to mask background voxels. It processes a control subject’s N4-corrected, rigidly aligned image via an R script (WhiteStripe package) called through rpy2, then visualizes the mask at the stripe’s centroid coordinates derived from the affine transform. The rendering uses a HSV colormap for the stripe overlay.
This interactive WebGL visualization explores MRI volumetric reliability and power for a non-standardized multisite study. It displays power curves and reliability metrics across multiple sites, showing how the number of sites, effect size, and between-site intraclass correlation (ICC) affect statistical power to detect genetic effects on brain volumes. Built with Vue and WebGL rendering, the visualization presents tables and figures from the underlying statsmodels analysis, including test-retest reliability, between-site ICCs, and calibration results for gray and white matter volumes.
This visualization presents the results of a two-sample t-test comparing brain activation between MDD and healthy control groups across multiple regions of interest. It displays thresholded z-statistic maps for different brain ROIs using sliced image views with color-coded activation patterns, where hot colors indicate one comparison direction and blues indicate the other. The implementation uses Python with NumPy and NiBabel for image processing and nipy's plot_map for visualization. The code loads NIfTI files, labels connected components above a threshold, and generates labeled anatomical slices.
This interactive slideshow presents a statistical analysis of MRI volumetric reliability and power across non-standardized multisite studies, focusing on multiple sclerosis research. It shows how between-site reliability varies and demonstrates that aggregating data from 7–12 sites enables detection of small disease effects. The notebook uses Python with statsmodels, NumPy, and IPython.display, rendering inline matplotlib plots via the `%pylab` magic command. The WebGL-based Vue interface displays the notebook cells as slide-style content, with tables and figures illustrating ICC values, power curves, and calibration results for gray and white matter volumes.
This example visualizes intraclass correlations for within- and between-site reliability of brain volume estimates from Freesurfer and SIENAX across multicenter MS study scans. It presents a pandas DataFrame table of scanning parameters and reliability metrics for nine scanners at six sites. The code uses IPython’s `%pylab inline` for interactive plotting, pandas for tabular data handling, and nipype’s `loadpkl` to load the analysis results. The visualization is built in a Jupyter notebook with Vue integration, showing how heterogeneous acquisition protocols affect measurement consistency.
This example demonstrates a spectral clustering workflow for neuroimaging data, using scikit-learn’s `SpectralClustering` to segment thalamus voxels into distinct clusters based on correlation matrices. It processes fMRI time-series data via Nipype pipelines, nibabel for image I/O, and matplotlib with `%pylab inline` for visualization. The notebook shows how clustering results are saved as NIfTI files, with parameters like subject ID, region of interest, and cluster count varied across runs.
This visualization presents the variance of brain volume estimates from Freesurfer 5.3.0 across multiple MRI sites and scanners, using data from a multicenter study of traveling subjects. It shows how T1-weighted scans from different sites compare in terms of acquisition counts and subsequent volume metrics. The example uses Vue.js with WebGL rendering for interactive display. The underlying analysis relies on pandas for data manipulation, NumPy for numerical operations, and Matplotlib with Seaborn styling, as seen in the notebook’s code cells that load demographic, NIfTI, and Freesurfer CSV files.
This example shows a Jupyter notebook template that hides input cells and reveals them on demand when a user clicks an output area, using jQuery to toggle visibility. The notebook’s rendered HTML is styled so code and text are centered, with hidden prompts and a custom font size for code blocks. The template extends the base HTML exporter and relies on jQuery’s `slideToggle` to animate the display of input sections, while CSS controls layout and typography. It demonstrates a reusable approach for converting notebook content into an interactive, cleanly formatted web page.
This visualization demonstrates how linear calibration transforms MRI brain volume measurements from two scanner sites, comparing simulated models that combine variables, add site regressors, or calibrate data to evaluate equivalence between scanners. It uses Python with numpy, matplotlib, seaborn, statsmodels, scipy, and rpy2 to run ordinary least squares and robust linear models, while rendering plots inline via IPython Notebook.
This interactive visualization simulates MRI brain volume data from two scanner sites, comparing healthy controls and multiple sclerosis patients across age and disease severity. It applies linear calibration transformations between sites and tests statistical models, including OLS for controls and robust linear regression for patients. Built with Vue and WebGL, the notebook uses Python with matplotlib, seaborn, and pandas to generate and analyze the synthetic datasets, displaying distributions and regression fits interactively.
This example simulates multi-site MRI data to test how brain volume relates to age and disease severity across two scanner sites, comparing calibration strategies for cross-site analysis. It uses a Jupyter notebook with Python, plotting the simulated relationships through matplotlib and seaborn, and applies ordinary least squares and robust linear models via the statsmodels API. The notebook defines governing equations with parameters like scanner scaling and offset, then generates synthetic control and patient cohorts to evaluate how site effects and EDSS scores influence brain volume estimates.
This example simulates multi-site MRI data to illustrate how brain volume relates to age and disease severity across patient and control groups. It compares three statistical models for combining site data, including a linear calibration transformation. The notebook uses Python with NumPy, Matplotlib, seaborn, and statsmodels to generate synthetic data and fit ordinary least squares and robust linear models.
This example demonstrates a simulated data analysis workflow for studying brain volume (BV) differences between healthy controls (HC) and multiple sclerosis (MS) patients across two sites. The notebook defines a synthetic data generator that creates age, disability (EDSS), and brain volume measurements for healthy controls and MS patients under two different scanning protocols, then calibrates measurements between the two sites. Using ordinary least squares regression via the `statsmodels` library, it fits models relating brain volume to age and disease severity, then applies a calibration transformation to harmonize measurements across sites. The visualization likely shows scatter plots of the simulated data with regression lines, illustrating the calibration process and residual patterns. The example demonstrates a statistical approach to cross-site calibration of imaging biomarkers in the presence of disease-related effects.
This visualization demonstrates simulated brain volume (BV) measurements across healthy controls (HC) and multiple sclerosis (MS) patients, generated with a custom Python function. The simulation models two distinct "sites" or protocols, each with its own disease severity distribution (EDSS-like scores) and age-dependent brain volume trends. Parameters include group sizes (50 HC, 250 MS), age ranges, disease severity mixture distributions, and linear relationships between age, disability, and brain volume with added noise. The example includes a plot of the simulated disability scores for both sites, created using matplotlib inline in an IPython notebook. Built with the Vue framework, the visualization highlights how simulated data can be used to explore statistical estimation and model assumptions in neuroimaging studies.
This example simulates brain-volume measurements for healthy controls and multiple-sclerosis patients across two scan protocols, using synthetic data generated with NumPy and Statsmodels. It shows how measurement noise and protocol-related biases affect the relationship between age, disability scores, and brain volume. The visualization displays the simulated distributions and calibration results, with matplotlib and prettyplotlib rendering static plots. The code relies on inline plotting via `%pylab` and custom utility functions for distribution and calibration analysis, though no interactive or WebGL output is present in the provided notebook cells.
This example simulates brain volume and disability data for healthy controls and multiple sclerosis patients across two sites, generating synthetic datasets with site-specific EDSS distributions. It uses Python with statsmodels and matplotlib via prettyplotlib to plot the simulated distributions, including scatterplots and regression fits that illustrate relationships between age, brain volume, and EDSS scores. The visualization is part of a Vue-based gallery, but the core computation and plotting rely on numpy and statsmodels for statistical simulation and visualization.
This example shows how changing simulation parameters affects a statistical model of brain volume across multiple sites. It displays calibration correlations between two imaging protocols and separates model coefficients for age and disease effects by site. The code uses Python with matplotlib, numpy, statsmodels (OLS and RLM), and prettyplotlib to generate plots, while a Vue-based interface likely controls the adjustable inputs.
This example simulates MRI brain-volume data from two sites, modeling healthy controls and patients with age and disease metrics to evaluate linear calibration transformations between sites. It compares ordinary least squares and robust linear models for estimating brain volume, testing three cross-site approaches: combined variables, combined with a site regressor, and calibrated site-2 measurements. The code uses NumPy for data generation, Statsmodels for regression models, and Matplotlib with prettyplotlib for visualization, while the notebook structure relies on IPython’s inline plotting.
This visualization simulates multi-site MRI data, modeling brain volume across two sites for control and patient groups, and compares three regression strategies for combining site data, including a linear calibration transformation. It shows how model predictions and confidence intervals vary across age and disease metrics. Built in a Jupyter notebook, the code uses NumPy for data generation, statsmodels for ordinary least squares and robust linear model fitting, and matplotlib with prettyplotlib for plotting the results.
This example visualizes the distribution of mean free energy (ΔG) values for overlapping 500-base-pair sub-sequences of the p7308 genome. The notebook computes these values using NuPack’s mfe binary through a Nipype pipeline, then plots a histogram of the results with matplotlib and prettyplotlib. The code extracts ΔG values from text output files and displays the histogram with 30 bins, labeled axes, and a title indicating the sequence length and temperature.
A histogram displays the distribution of calculated free-energy values (ΔG) for 500-base-pair subsequences of the p7308 genome, with results extracted from NuPack’s minimum free energy (mfe) output files. The plot uses matplotlib via prettyplotlib to render 30 bins, labeling axes with ΔG and sequence count, and titles the figure with the temperature condition. The underlying pipeline processed 7,308 subsequences, as indicated by the file count and extraction function.
The visualization shows the output of `brew doctor` as a playful, abstract composition. It displays the command’s success message, “Your system is raring to brew,” alongside a small set of decorative, animated elements. The piece uses d3.forceSimulation to position and gently move the text and shapes, while d3.select and transition methods handle their entrance and motion. The data originates from a plain-text terminal log, rendered as a minimal, whimsical scene rather than a conventional chart. The code relies on d3’s selection, transition, and force APIs to create the lightweight, non-interactive animation.
This visualization tracks the build log of Boost 1.47.0, showing each file-copy action from `common.copy` entries as it installs headers and libraries to Homebrew’s Cellar directory. The code uses `d3.forceSimulation` to position nodes and Canvas rendering to draw the evolving network of dependencies and copied files. It highlights the sequence of compilation steps, including ICU detection and MPI warnings, while visualizing the file system hierarchy as a directed graph. The data source is the raw gistfile1.txt output, parsed line-by-line to extract copy operations.