Pycortex

https://gallantlab.org/pycortex/
Admin
Pycortex is a software package for generating interactive 3D visualizations of fMRI data projected...
Tokens:309,943
Snippets:1,117
Trust Score:9.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install IPython

Source: https://gallantlab.org/pycortex/_sources/install

Installs the IPython interactive shell, which is recommended for using pycortex and running its demo.

```bash
pip install ipython
```

--------------------------------

### Find pycortex Configuration and Filestore

Source: https://gallantlab.org/pycortex/auto_examples/quickstart/index

This example shows how to locate the configuration files and the filestore directory used by pycortex. This is useful for understanding where pycortex stores its settings and data.

```python
import cortex

# Get the config directory
config_dir = cortex.get_config_dir()
print(f"Pycortex config directory: {config_dir}")

# Get the filestore directory
filestore_dir = cortex.get_filestore_dir()
print(f"Pycortex filestore directory: {filestore_dir}")
```

--------------------------------

### Locate pycortex Configuration and Filestore

Source: https://gallantlab.org/pycortex/_sources/auto_examples/quickstart/index

This example demonstrates how to easily find your pycortex configuration file and filestore locations. This is useful for troubleshooting issues related to incorrect configuration.

```python
import cortex

# Get the path to the configuration file
config_path = cortex.get_config_file()
print(f"Configuration file location: {config_path}")

# Get the filestore location
filestore_path = cortex.get_filestore()
print(f"Filestore location: {filestore_path}")

```

--------------------------------

### Plot Retinotopy Data on Flatmap

Source: https://gallantlab.org/pycortex/_sources/auto_examples/quickstart/index

This demo shows how to plot example retinotopy data onto a subject's brain represented as a flatmap. Similar to the webgl example, the dataset can be downloaded automatically via a urllib command.

```python
import cortex
import numpy as np

# Load example retinotopy data (assuming it's available or downloaded)
# For demonstration, let's create dummy data
data = np.random.rand(100, 100)

# Plot the data on a flatmap
cortex.plotflat(data)

# To save the flatmap, you might use:
# cortex.plotflat(data, outfile='retinotopy_flatmap.png')

```

--------------------------------

### Start Freesurfer Environment

Source: https://gallantlab.org/pycortex/_sources/segmentation_guide

Command to source the Freesurfer setup script, which configures the environment variables necessary to run Freesurfer commands. Requires the path to the Freesurfer installation.

```bash
source_directory_name_here/SetUpFreeSurfer.sh
```

```bash
/auto/myfolder/freesurfer/SetUpFreeSurfer.sh
```

--------------------------------

### Install PyCortex Stable Release

Source: https://gallantlab.org/pycortex/_sources/install

Installs the stable release of pycortex and its required dependencies using pip. This includes setuptools, wheel, numpy, and cython.

```bash
pip install -U setuptools wheel numpy cython
pip install -U pycortex
```

--------------------------------

### Install PyCortex Development Version

Source: https://gallantlab.org/pycortex/_sources/install

Installs the development version of pycortex directly from its GitHub repository using pip. This command fetches the latest code from the main branch.

```bash
pip install -U git+https://github.com/gallantlab/pycortex.git
```

--------------------------------

### Get user config path

Source: https://gallantlab.org/pycortex/_sources/auto_examples/quickstart/show_config

Prints the path to the user's configuration file. This is useful for verifying the configuration setup.

```Python
print(cortex.options.usercfg)
```

--------------------------------

### Plot Retinotopy Data in WebGL Viewer

Source: https://gallantlab.org/pycortex/_sources/auto_examples/quickstart/index

This demo illustrates how to plot example retinotopy data onto a subject's brain within a web viewer. The dataset can be downloaded automatically using a provided urllib command.

```python
import cortex
import numpy as np

# Load example retinotopy data (assuming it's available or downloaded)
# For demonstration, let's create dummy data
data = np.random.rand(100, 100)

# Plot the data on a flatmap
cortex.quickshow(data)

# To plot in a web viewer, you might use a different function or setup
# Example (conceptual, actual implementation may vary):
# viewer = cortex.webshow(data)
# viewer.save('retinotopy_webgl.html')

```

--------------------------------

### Plot Retinotopy in WebGL Viewer

Source: https://gallantlab.org/pycortex/auto_examples/quickstart/index

Demonstrates how to plot retinotopy data and visualize it in a WebGL viewer. This example likely involves importing data, processing it, and rendering it using pycortex's visualization capabilities.

```python
import cortex
import numpy as np

# Load sample data (replace with your actual data)
volume = cortex.db.volumes['fsaverage']['inflated']
flatmap = cortex.db.get_flatmap('fsaverage', 'inflated')

# Create dummy data for demonstration
data = np.random.rand(volume.shape[0])

# Create a Volume object
v_data = cortex.Volume(data, volume, vmin=0, vmax=1)

# Plot in WebGL viewer
cortex.webshow(v_data)
```

--------------------------------

### Plot Retinotopy Flatmaps

Source: https://gallantlab.org/pycortex/auto_examples/quickstart/index

This example demonstrates how to generate and display retinotopy data on flatmaps using pycortex. It involves loading surface data and plotting specific visual field representations.

```python
import cortex
import numpy as np

# Load flatmap data (replace with your actual data)
flatmap = cortex.db.get_flatmap('fsaverage', 'inflated')

# Create dummy retinotopy data
# Assuming 'retinotopy' is a standard dataset available or loaded
# For demonstration, creating random data
ret_data = np.random.rand(flatmap.shape[0])

# Create a Flatmap object
f_data = cortex.Flatmap(ret_data, flatmap, vmin=0, vmax=1)

# Plot the flatmap
cortex.show(f_data)
```

--------------------------------

### Configure PyCortex Filestore Path

Source: https://gallantlab.org/pycortex/install

An example configuration snippet for the PyCortex user options file, demonstrating how to specify a custom absolute path for the filestore.

```INI
[basic]
filestore=/abs/path/to/filestore
```

--------------------------------

### Run PyCortex Demo

Source: https://gallantlab.org/pycortex/_sources/install

Executes the pycortex demo within an IPython session. This involves importing the cortex library and using the webshow function with a random volume.

```python
import cortex
cortex.webshow(cortex.Volume.random("S1", "fullhead"))
```

--------------------------------

### Run PyCortex Demo

Source: https://gallantlab.org/pycortex/install

Executes a demo using PyCortex within an IPython session. It imports the library and displays a random volume, which should open in a web browser if the installation is successful.

```Python
$ ipython
In [1]: import cortex
In [2]: cortex.webshow(cortex.Volume.random("S1", "fullhead"))
```

--------------------------------

### Plot Volume Data

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

This example plots volume data onto an example subject's flatmap using quickflat. A flatmap for the specified subject must exist in the pycortex filestore for this to run successfully.

```python
import cortex

# Load example volume data
volume_data = cortex.db.get_volume('S1', 'flat')

# Plot the volume data on a flatmap
cortex.quickflat.makeflat(volume_data, 'S1')

```

--------------------------------

### Install IPython

Source: https://gallantlab.org/pycortex/install

Installs IPython, an enhanced interactive Python shell that is recommended for using PyCortex and running its demo.

```Shell
pip install ipython
```

--------------------------------

### Plot RGB Vertex Data

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

This example plots RGB vertex data onto an example subject's flatmap using quickflat. It requires a flatmap for the subject to be available in the pycortex filestore.

```python
import cortex
import numpy as np

# Create example RGB vertex data (3 channels)
rgb_vertex_data = np.random.rand(10000, 3)

# Plot the RGB vertex data on a flatmap
cortex.quickflat.makeflat(rgb_vertex_data, 'S1')

```

--------------------------------

### Plot RGB Volume Data

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

This example plots an RGB dataset onto an example subject's flatmap using quickflat. Ensure that a flatmap for the subject exists in the pycortex filestore prior to running this code.

```python
import cortex
import numpy as np

# Create example RGB volume data (3 channels)
rgb_volume_data = np.random.rand(64, 64, 64, 3)

# Plot the RGB volume data on a flatmap
cortex.quickflat.makeflat(rgb_volume_data, 'S1')

```

--------------------------------

### Plot Vertex Data

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

This example plots vertex data onto an example subject's flatmap using quickflat. It requires a pre-existing flatmap for the specified subject in the pycortex filestore.

```python
import cortex

# Load example vertex data
vertex_data = cortex.db.get_vertex('S1', 'flat')

# Plot the vertex data on a flatmap
cortex.quickflat.makeflat(vertex_data, 'S1')

```

--------------------------------

### Plot 2D Volume Data

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

This example plots 2D volume data onto an example subject's flatmap using quickflat. A flatmap for the subject must be present in the pycortex filestore for this operation.

```python
import cortex
import numpy as np

# Create example 2D volume data
volume_data_2d = np.random.rand(64, 64, 64, 2)

# Plot the 2D volume data on a flatmap
cortex.quickflat.makeflat(volume_data_2d, 'S1')

```

--------------------------------

### Plot 2D Vertex Data

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

This example plots 2D vertex data onto an example subject's flatmap using quickflat. Ensure that a flatmap for the subject is available in the pycortex filestore before execution.

```python
import cortex
import numpy as np

# Create example 2D vertex data
vertex_data_2d = np.random.rand(10000, 2)

# Plot the 2D vertex data on a flatmap
cortex.quickflat.makeflat(vertex_data_2d, 'S1')

```

--------------------------------

### Plot Dataset Arithmetic

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

This example plots arithmetic operations on dataset volumes onto an example subject's flatmap using quickflat. It requires a pre-existing flatmap for the specified subject in the pycortex filestore.

```python
import cortex
import numpy as np

# Load example data
data = cortex.db.get_volume('S1', 'flat')

# Perform dataset arithmetic
result = data + 5

# Plot the result
cortex.quickflat.makeflat(result, 'S1')

```

--------------------------------

### Source Freesurfer Setup Script

Source: https://gallantlab.org/pycortex/segmentation_guide

Executes the Freesurfer setup script to configure the environment for using Freesurfer tools. This is a prerequisite for running most Freesurfer commands.

```bash
source_directory_name_here/SetUpFreeSurfer.sh
```

--------------------------------

### Plot Static 2D Flatmap

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

This example demonstrates the basic usage of PyCortex's `quickflat.make_figure()` function to generate static, high-quality 2D flatmaps using Matplotlib.

```python
import cortex
import cortex.quickflat

# Example: Create a static flatmap
# data = cortex.get_data('mydata')
# fig = cortex.quickflat.make_figure(data)
# fig.savefig('flatmap.png')

# Placeholder for the actual code to plot a static flatmap
print('Code to plot a 2D static flatmap using cortex.quickflat.make_figure() would go here.')
```

--------------------------------

### Check PyCortex Default Filestore Location

Source: https://gallantlab.org/pycortex/_sources/install

Retrieves and prints the default location of the pycortex database filestore after installation.

```python
import cortex
cortex.database.default_filestore
```

--------------------------------

### Import pycortex and config

Source: https://gallantlab.org/pycortex/_sources/auto_examples/quickstart/show_config

Imports necessary modules from the cortex library to access configuration settings.

```Python
from __future__ import print_function
import cortex
from cortex.options import config
```

--------------------------------

### Get ROI Index Volume

Source: https://gallantlab.org/pycortex/auto_examples/utils/index

This example shows how to retrieve a volume where each voxel is assigned an index corresponding to the ROI it belongs to, using pycortex. This is useful for volumetric ROI analysis.

```Python
import cortex
import numpy as np

# Get the ROI index volume for a subject
roi_index_volume = cortex.get_roi_index_volume('fsaverage')
print(f"ROI index volume shape: {roi_index_volume.shape}")
```

--------------------------------

### Inspect config file sections and items

Source: https://gallantlab.org/pycortex/_sources/auto_examples/quickstart/show_config

Demonstrates how to list all sections within the configuration file and retrieve key-value pairs for a specific section ('paths_default').

```Python
# sections gets the upper-level sections in the config file
sections = config.sections()
print(sections)

# items gets the option items within a section as a list of key-value pairs.
basic_config = config.items('paths_default')
print(basic_config)
```

--------------------------------

### Get Vertices for an ROI

Source: https://gallantlab.org/pycortex/auto_examples/utils/index

This example demonstrates how to retrieve the vertices associated with a specific Region of Interest (ROI) within the pycortex library. It is useful for analyzing specific brain areas.

```Python
import cortex
import numpy as np

# Load an example dataset
data = cortex.db.get_roi('V1')

# Get the vertices for the ROI
vertices = data['vertices']
print(f"Number of vertices in V1: {len(vertices)}")
```

--------------------------------

### Get ROI Voxel Mask

Source: https://gallantlab.org/pycortex/auto_examples/utils/index

This example shows how to obtain a voxel mask for a specific Region of Interest (ROI) using pycortex. A voxel mask can be used to isolate data within that ROI.

```Python
import cortex
import numpy as np

# Get the voxel mask for the 'V1' ROI
roi_mask = cortex.get_roi_voxel_mask('fsaverage', 'V1')
print(f"ROI mask shape: {roi_mask.shape}")
```

--------------------------------

### Get ROI Voxel Mask and Plot

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

Explains how to obtain the proportion of each voxel within a named ROI, creating a probabilistic ROI mask. The example also shows how to plot this mask onto a flatmap.

```python
import cortex
import numpy as np

# Assume 'subject' is a PyCortex Subject object
# subject = cortex.db.get_subj('fsaverage', 'std')

# Example: Create dummy subject data
subject = 'fsaverage'

# Get probabilistic ROI mask for 'V1'
roi_mask = cortex.utils.get_roi_voxel_mask(subject, 'V1')

# Plot the ROI mask on a flatmap
cortex.utils.plot_roi_voxel_mask(subject, 'V1')

# Alternatively, create a Volume from the mask and plot
# roi_volume = cortex.Volume.from_array(roi_mask, subject=subject)
# cortex.view(roi_volume)
```

--------------------------------

### Save Flatmap as PNG - pycortex

Source: https://gallantlab.org/pycortex/_sources/auto_examples/quickflat/index

Shows how to create a 2D static flatmap and save it as a PNG file.

```python
import cortex
import cortex.quickflat

# Load data (example)
subject = 'sample_subject'
xfm_name = 'sample_xfm'

fig = cortex.quickflat.make_figure(subject, xfm_name)
cortex.quickflat.save_flatmap(fig, 'flatmap.png')

```

--------------------------------

### Animate Volumes as GIF

Source: https://gallantlab.org/pycortex/auto_examples/quickflat/index

Illustrates how to create an animation of a series of volumes as a GIF file using pycortex. This is useful for visualizing dynamic changes in brain activity over time.

```python
import cortex
import matplotlib.pyplot as plt

# Load example volume data (replace with your actual time series data)
volumes = [cortex.db.get_volume('fsaverage', 'thickness') for _ in range(5)] # Example: 5 identical volumes

# Create flatmaps for each volume
flatmaps = [cortex.flatmap.make_flatmap(v) for v in volumes]

# Animate the flatmaps as a GIF
cortex.plot.animate_flatmaps(flatmaps, 'animation.gif', interval=200)
print('Animation saved as animation.gif')
```

--------------------------------

### Find PyCortex Config and Filestore Locations

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

This example provides guidance on locating PyCortex's configuration file and filestore directories. This is particularly useful for troubleshooting issues related to incorrect configuration settings.

```python
import cortex

# Example: Show config and filestore locations
# print(cortex.get_config())
# print(cortex.filestore_path)

# Placeholder for the actual code to find config and filestore locations
print('Code to find out where the config and filestore are would go here.')
```

--------------------------------

### Configure PyCortex Filestore Location

Source: https://gallantlab.org/pycortex/_sources/install

Demonstrates how to update the pycortex user configuration file to specify an alternate location for the filestore.

```ini
[basic]
filestore=/abs/path/to/filestore
```

--------------------------------

### Create 3D WebGL Viewer with Multiple Datasets

Source: https://gallantlab.org/pycortex/auto_examples/index

Shows how to create a single interactive 3D WebGL viewer that displays multiple datasets simultaneously, allowing for direct comparison.

```Python
import cortex
import cortex.viewer
import numpy as np

# Load a sample surface
subj = 'sample'
cortex.db.use_subjects([subj])

# Create multiple Volume objects with different data
num_vertices = cortex.get_num_vertices(subj)
data1 = np.random.rand(num_vertices)
data2 = np.random.rand(num_vertices)

vol1 = cortex.Volume(data1, subj, 'dataset1', xfmname='identity')
vol2 = cortex.Volume(data2, subj, 'dataset2', xfmname='identity')

# Create and display the WebGL viewer with multiple datasets
cortex.viewer.view([vol1, vol2])
```

--------------------------------

### Get Vertices for an ROI

Source: https://gallantlab.org/pycortex/auto_examples/index

Demonstrates how to retrieve the vertex indices that belong to a specific Region of Interest (ROI) on a brain surface. This is fundamental for targeted analysis.

```Python
import cortex

# Load a sample surface
subj = 'sample'
cortex.db.use_subjects([subj])

# Specify the ROI name
roi_name = 'V1'

# Get the vertex indices for the ROI
roi_vertices = cortex.get_roi_vertices(subj, roi_name)

print(f"Vertices for ROI '{roi_name}': {roi_vertices[:10]}...")
```

--------------------------------

### Import PyCortex and Options

Source: https://gallantlab.org/pycortex/_downloads/5ec582772cb6c68c66aedc35da2aec38/show_config

Imports necessary modules from the pycortex library, including the 'config' object for accessing configuration settings. This is a prerequisite for the following examples.

```python
from __future__ import print_function
import cortex
from cortex.options import config
```

--------------------------------

### Check PyCortex User Configuration File Location

Source: https://gallantlab.org/pycortex/_sources/install

Retrieves and prints the location of the pycortex user configuration file, which allows for customization of settings.

```python
import cortex
cortex.options.usercfg
```

--------------------------------

### Plot a 2D Static Flatmap

Source: https://gallantlab.org/pycortex/_sources/auto_examples/quickflat/index

This example shows how to use pycortex's quickflat visualizations with matplotlib to generate figure-quality 2D flatmaps. It covers the basic process of creating a static flatmap visualization.

```python
import cortex.quickflat as qf
import matplotlib.pyplot as plt

# Assuming 'data' is a PyCortex Volume object or similar

# Create a figure and axes
fig, ax = plt.subplots()

# Generate the 2D static flatmap
qf.make_figure(data, ax=ax)

plt.show()
```

--------------------------------

### Get ROI Index Volume

Source: https://gallantlab.org/pycortex/auto_examples/index

Demonstrates how to create a volumetric representation where each voxel is assigned an index corresponding to the ROI it belongs to. This is useful for volumetric ROI analysis.

```Python
import cortex

# Load a sample surface
subj = 'sample'
cortex.db.use_subjects([subj])

# Get the ROI index volume
roi_index_volume = cortex.get_roi_index_volume(subj)

print(f"ROI index volume shape: {roi_index_volume.shape}")
```

--------------------------------

### Get ROI Voxel Mask and Plot in pycortex

Source: https://gallantlab.org/pycortex/_sources/auto_examples/utils/index

Calculates the proportion of each voxel that lies within a named ROI, creating a probabilistic ROI mask. This mask can then be visualized on a flatmap.

```python
import cortex
import numpy as np

# Load ROI and volume data (replace with your data)
roi_name = "your_roi_name"
volume_data = np.random.rand(64, 64, 64)

# Get probabilistic ROI mask
roi_mask = cortex.get_roi_voxel_mask(roi_name, volume_data)

# Plot the ROI mask on a flatmap (requires a subject surface)
cortex.plot_roi_mask(roi_mask, "SubjectName", "your_roi_name")

```

--------------------------------

### Create a 3D WebGL Viewer

Source: https://gallantlab.org/pycortex/auto_examples/index

Shows how to create an interactive 3D viewer using WebGL, allowing users to explore brain surfaces and data in a web browser.

```Python
import cortex
import cortex.viewer

# Load a sample surface and data
subj = 'sample'
cortex.db.use_subjects([subj])

# Create a Volume object with some data
# Example: dummy data
num_vertices = cortex.get_num_vertices(subj)
data = np.random.rand(num_vertices)
vol = cortex.Volume(data, subj, 'mydata', xfmname='identity')

# Create and display the WebGL viewer
cortex.viewer.view(vol)
```

--------------------------------

### Get ROI Voxel Mask

Source: https://gallantlab.org/pycortex/auto_examples/index

Shows how to obtain a voxel mask corresponding to a specific Region of Interest (ROI). This mask can be used to extract or analyze data within that ROI from volumetric data.

```Python
import cortex

# Load a sample surface
subj = 'sample'
cortex.db.use_subjects([subj])

# Specify the ROI name
roi_name = 'V1'

# Get the voxel mask for the ROI
roi_mask = cortex.get_roi_mask(subj, roi_name)

print(f"ROI mask shape: {roi_mask.shape}")
```

--------------------------------

### Get Vertices for an ROI in pycortex

Source: https://gallantlab.org/pycortex/_sources/auto_examples/utils/index

Demonstrates how to retrieve vertices that fall within a specified ROI defined in an SVG ROI file. This is useful for analyzing data associated with specific brain regions.

```python
import cortex
import numpy as np

# Load an ROI file (replace with your ROI file path)
roi_file = "path/to/your/roi.svg"
roi_name = "your_roi_name"

# Get vertices within the ROI
vertices_in_roi = cortex.get_roi_vertices(roi_file, roi_name)

print(f"Vertices in ROI '{roi_name}': {len(vertices_in_roi)}")

```

--------------------------------

### Create a 3D WebGL Viewer with Multiple Datasets

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

This example shows how to create a 3D WebGL viewer using PyCortex that can display data from multiple sources simultaneously. It covers the process of loading and integrating different datasets into a single, interactive visualization within a web browser.

```python
import cortex
import numpy as np

# Example of creating a 3D WebGL viewer with multiple datasets
# (Actual code for loading and displaying datasets would be here)
print("Creating a 3D WebGL viewer with multiple datasets.")

```

```html
<div class="sphx-glr-thumbcontainer" tooltip="A webgl viewer displays a 3D view of brain data in a web browser">
  <img src="/auto_examples/webgl/images/thumb/sphx_glr_multiple_datasets_thumb.png" alt=""/>
  <p>Create a 3D WebGL Viewer with Multiple Datasets</p>
</div>
```

--------------------------------

### Get Vertices for an ROI

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

Demonstrates how to retrieve the specific vertices that fall within a Region of Interest (ROI) defined in an SVG ROI file. This is a utility function for isolating specific brain areas for analysis.

```python
import cortex
import cortex.datasets

# Load a sample datasetxfm = cortex.db.get_trans('avg', 'retinotopy')
data = cortex.datasets.retinotopy.load()

# Specify the ROI name (assuming 'V1' is defined in an SVG file)
roi_name = 'V1'

# Get vertices for the ROI
roi_vertices = cortex.get_roi_vertices(data['V1'], xfm, roi_name)

print(f"Vertices for ROI '{roi_name}': {roi_vertices[:10]}...") # Print first 10 vertices
```

--------------------------------

### PyCortex: Find Config and Filestore Locations

Source: https://gallantlab.org/pycortex/auto_examples/index

Demonstrates how to find the locations of PyCortex configuration files and the filestore. This is essential for managing PyCortex data and settings.

```python
import cortex

# Get the path to the PyCortex configuration file
config_path = cortex.utils.get_config_file()
print(f"PyCortex config file location: {config_path}")

# Get the path to the PyCortex filestore
filestore_path = cortex.utils.get_filestore_path()
print(f"PyCortex filestore location: {filestore_path}")
```

--------------------------------

### Import fmriprep output

Source: https://gallantlab.org/pycortex/_sources/auto_examples/index

This example shows how to import the output from the fmriprep preprocessing workflow into PyCortex. PyCortex provides a convenience function to handle this import process, facilitating the visualization of fmriprep results.

```Python
import cortex

# Specify the path to your fmriprep output directory
fmriprep_dir = '/path/to/your/fmriprep/output'
subject_id = 'your_subject_id'

# Import the fmriprep output using PyCortex
cortex.utils.import_fmriprep(fmriprep_dir, subject_id)

# Now you can load and visualize the imported data using PyCortex
```

--------------------------------

### Get ROI Index Volume in pycortex

Source: https://gallantlab.org/pycortex/_sources/auto_examples/utils/index

Creates an index volume where each ROI is assigned a unique integer index. ROIs in the left hemisphere are represented by negative values, and right hemisphere ROIs by positive values.

```python
import cortex
import numpy as np

# Load ROI data (replace with your ROI data)
roi_data = np.random.randint(0, 10, size=(64, 64, 64))

# Generate index volume
index_volume = cortex.plot_roi_voxel_index_volume(roi_data)

print(f"Index volume shape: {index_volume.shape}")

```

--------------------------------

### Animate Flatmaps as GIF - pycortex

Source: https://gallantlab.org/pycortex/_sources/auto_examples/quickflat/index

Provides a method to create an animated GIF by flipping between a series of flatmaps, useful for comparing data like prediction performance or tuning weights.

```python
import cortex
import cortex.quickflat

# Load data (example)
subject = 'sample_subject'
xfm_name = 'sample_xfm'

# Create a series of flatmaps (example)
flatmaps = []
for i in range(5):
    flatmaps.append(cortex.quickflat.make_figure(subject, xfm_name, layer=f'layer_{i}'))

cortex.quickflat.save_animation(flatmaps, 'animation.gif')

```

--------------------------------

### Install PyCortex Development Version

Source: https://gallantlab.org/pycortex/install

Installs the latest development version of PyCortex directly from its GitHub repository. This is useful for users who want the newest features or are contributing to the project.

```Shell
# Install development version of pycortex from github
pip install -U git+https://github.com/gallantlab/pycortex.git
```

--------------------------------

### Install PyCortex Stable Release

Source: https://gallantlab.org/pycortex/install

Installs the latest stable release of PyCortex along with its essential dependencies (setuptools, wheel, numpy, cython). This is the recommended method for most users.

```Shell
# First, install some required dependencies
pip install -U setuptools wheel numpy cython
# Install the latest release of pycortex from pip
pip install -U pycortex
```

--------------------------------

### Plot with Advanced Compositing

Source: https://gallantlab.org/pycortex/auto_examples/quickflat/index

Shows how to use advanced compositing techniques for plotting data on a flatmap with pycortex. This allows for more sophisticated visualization by combining multiple layers or effects.

```python
import cortex
import matplotlib.pyplot as plt

# Load example data (replace with your actual data)
volume = cortex.db.get_volume('fsaverage', 'thickness')
flatmap = cortex.flatmap.make_flatmap(volume)

# Define overlay data (e.g., sulci)
sulci_overlay = cortex.overlay.get_overlay('fsaverage', 'sulci')

# Plot with advanced compositing (e.g., overlaying sulci with transparency)
cortex.plot.plot(flatmap, overlay=sulci_overlay, cmap='viridis', alpha=0.7)
plt.show()
```

--------------------------------

### Plotting a Zoomed View of One ROI

Source: https://gallantlab.org/pycortex/_sources/auto_examples/quickflat/index

This example demonstrates how to create a flatmap zoomed in on a single ROI. The location of the ROI is automatically inferred, simplifying the process of displaying a specific region.

```python
import cortex.quickflat as qf
import matplotlib.pyplot as plt

# Assuming 'data' is a PyCortex Volume object or similar
# and 'roi_name' is the name of the ROI to zoom into

# Create a figure and axes
fig, ax = plt.subplots()

# Plot the flatmap, zooming into the specified ROI
qf.make_figure(data, ax=ax, roi=roi_name)

plt.show()
```
Tokens:
Raw