Starfish

https://spacetx-starfish.readthedocs.io/en/latest/
Admin
Starfish is a Python library for processing image-based spatial transcriptomics data to build...
Tokens:358,001
Snippets:2,717
Trust Score:9.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install starfish on Windows (cmd.exe)

Source: https://spacetx-starfish.readthedocs.io/en/latest/installation/index.html

Install starfish in a virtual environment on Windows using cmd.exe. Includes installing napari first.

```bash
> mkdir starfish
> cd starfish
> python -m venv .venv
> .venv\Scripts\activate.bat
> pip install napari[all]
> pip install starfish

```

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

### Install napari and jupyter from requirements

Source: https://spacetx-starfish.readthedocs.io/en/latest/installation/index.html

Install napari and jupyter using the updated requirements files.

```bash
$ pip install -r requirements/REQUIREMENTS-NAPARI-CI.txt
$ pip install -r requirements/REQUIREMENTS-JUPYTER.txt

```

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

### Install starfish with napari

Source: https://spacetx-starfish.readthedocs.io/en/latest/installation/index.html

Install starfish with napari for interactive image visualization via display(). Note: on Windows or Apple Silicon, install napari first.

```bash
$ pip install starfish[napari]

```

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

### Install starfish from GitHub

Source: https://spacetx-starfish.readthedocs.io/en/latest/installation/index.html

Install the most updated version directly from GitHub, as the PyPI release might be a few months behind the repo's master branch.

```bash
$ pip install starfish@git+https://github.com/spacetx/starfish.git

```

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

### Install starfish with jupyter

Source: https://spacetx-starfish.readthedocs.io/en/latest/installation/index.html

Install starfish with both napari and jupyter for notebook support.

```bash
$ pip install starfish[jupyter]

```

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

### Load Example Dataset

Source: https://spacetx-starfish.readthedocs.io/en/latest/_downloads/64554af2ad4ec2bc8c0f6d6693025070/plot_loading_data.ipynb

Load a formatted example dataset from the starfish.data sub-package. Use use_test_data=True to load a small subset of the full dataset.

```python
from starfish import data

# use_test_data for loading a small subset of full dataset
experiment = data.ISS(use_test_data=True)
experiment
```

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

### Load example dataset

Source: https://spacetx-starfish.readthedocs.io/en/latest/_downloads/d99d407bc8011bb627fe9dbfc416cba5/plot_quick_start.ipynb

Downloads the mouse vs human experiment and extracts primary and auxiliary ImageStacks.

```python
from starfish import data

# Download experiment
e = data.MOUSE_V_HUMAN()
# Load ImageStacks from experiment
imgs = e.fov().get_image('primary')  # primary images consisting of 4 rounds and 4 channels
dots = e.fov().get_image('dots')  # auxiliary image with all rolonies stained
nuclei = e.fov().get_image('nuclei')  # auxiliary image with dapi stain
```

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

### Install starfish with pip

Source: https://spacetx-starfish.readthedocs.io/en/latest/installation/index.html

Install the starfish package from PyPI using pip.

```bash
$ pip install starfish

```

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

### Create synthetic data for TileFetcher example

Source: https://spacetx-starfish.readthedocs.io/en/latest/gallery/data_formatting/plot_format_tilefetcher.html

This code generates synthetic image tiles for the example. It creates two directories (primary_dir and nuclei_dir) and saves ten-by-ten pixel TIFF files for each combination of fov, round, channel, and z-plane. The script uses numpy, scikit-image, and tempfile, and prints low contrast warnings.

```python
import os
import numpy as np
import skimage.io
import tempfile

# columns: r, ch, zplane
fovs = [
    [
        (0, 0, 0),
        (0, 0, 1),
        (0, 0, 2),
        (1, 0, 0),
        (1, 0, 1),
        (1, 0, 2),
    ],
    [
        (0, 0, 0),
        (0, 0, 1),
        (0, 0, 2),
        (1, 0, 0),
        (1, 0, 1),
        (1, 0, 2),
    ],
]

data = np.zeros((10, 10), dtype=np.float32)

# create example image tiles that adhere to the structured data schema
inputdir = tempfile.TemporaryDirectory()
primary_dir = os.path.join(inputdir.name, "primary_dir")
nuclei_dir = os.path.join(inputdir.name, "nuclei_dir")
os.mkdir(primary_dir)
os.mkdir(nuclei_dir)

for fov_id, fov in enumerate(fovs):
    for round_label, ch_label, zplane_label in fov:
        primary_path = os.path.join(
            primary_dir, f"primary-f{fov_id}-r{round_label}-c{ch_label}-z{zplane_label}.tiff")
        nuclei_path = os.path.join(
            nuclei_dir, f"nuclei-f{fov_id}-r{round_label}-c{ch_label}-z{zplane_label}.tiff")
        skimage.io.imsave(primary_path, data)
        skimage.io.imsave(nuclei_path, data)

```

```text
/home/docs/checkouts/readthedocs.org/user_builds/spacetx-starfish/envs/latest/lib/python3.10/site-packages/skimage/_shared/utils.py:328: UserWarning: /tmp/tmptwar1hpm/primary_dir/primary-f0-r0-c0-z0.tiff is a low contrast image
  return func(*args, **kwargs)
/home/docs/checkouts/readthedocs.org/user_builds/spacetx-starfish/envs/latest/lib/python3.10/site-packages/skimage/_shared/utils.py:328: UserWarning: /tmp/tmptwar1hpm/nuclei_dir/nuclei-f0-r0-c0-z0.tiff is a low contrast image
  return func(*args, **kwargs)
/home/docs/checkouts/readthedocs.org/user_builds/spacetx-starfish/envs/latest/lib/python3.10/site-packages/skimage/_shared/utils.py:328: UserWarning: /tmp/tmptwar1hpm/primary_dir/primary-f0-r0-c0-z1.tiff is a low contrast image
  return func(*args, **kwargs)
/home/docs/checkouts/readthedocs.org/user_builds/spacetx-starfish/envs/latest/lib/python3.10/site-packages/skimage/_shared/utils.py:328: UserWarning: /tmp/tmptwar1hpm/nuclei_dir/nuclei-f0-r0-c0-z1.tiff is a low contrast image
  return func(*args, **kwargs)
/home/docs/checkouts/readthedocs.org/user_builds/spacetx-starfish/envs/latest/lib/python3.10/site-packages/skimage/_shared/utils.py:328: UserWarning: /tmp/tmptwar1hpm/primary_dir/primary-f0-r0-c0-z2.tiff is a low contrast image
  return func(*args, **kwargs)
/home/docs/checkouts/readthedocs.org/user_builds/spacetx-starfish/envs/latest/lib/python3.10/site-packages/skimage/_shared/utils.py:328: UserWarning: /tmp/tmptwar1hpm/nuclei_dir/nuclei-f0-r0-c0-z2.tiff is a low contrast image
  return func(*args, **kwargs)
/home/docs/checkouts/readthedocs.org/user_builds/spacetx-starfish/envs/latest/lib/python3.10/site-packages/skimage/_shared/utils.py:328: UserWarning: /tmp/tmptwar1hpm/primary_dir/primary-f0-r1-c0-z0.tiff is a low contrast image
  return func(*args, **kwargs)

```

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

### Run starfish-workflow.py with example parameters

Source: https://spacetx-starfish.readthedocs.io/en/latest/user_guide/processing_at_scale/index.html

Command to run the starfish-workflow.py script with example parameters. The output shows the successful submission of the process fovs array job and the merge results job, each with a job ID.

```bash
$ python3 starfish-workflow.py \
>     --experiment-url "s3://aws-processing-example/iss-spacetx-formatted/experiment.json" \
>     --num-fovs 15 \
>     --recipe-location "s3://aws-processing-example/aws-processing-example/iss-spacetx-formatted/recipe.py" \
>     --results-bucket "s3://aws-processing-example/iss-spacetx-formatted-results/" \
>     --job-queue "first-run-job-queue"
Process fovs array job 39a13edd-8cca-4e7e-9379-aa3cf757c72e successfully submitted.
Merge results job ac5d49f5-a12e-4176-96e2-f697c6cf0a12 successfully submitted.
```

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

### Check Python version

Source: https://spacetx-starfish.readthedocs.io/en/latest/installation/index.html

Verify that your Python version is compatible (3.10-3.13) before installing starfish. The output should look similar to the example.

```bash
$ python --version
Python 3.10.19

```

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

### Set up virtual environment for development

Source: https://spacetx-starfish.readthedocs.io/en/latest/installation/index.html

Create and activate a virtual environment for starfish development.

```bash
$ python -m venv .venv
$ source .venv/bin/activate

```

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

### Import necessary libraries and define configuration

Source: https://spacetx-starfish.readthedocs.io/en/latest/_downloads/084e432482d962791db622b01b69cf95/format_iss_breast_data.ipynb

Initializes the environment by importing required modules and setting up the data source path.

```python
import os
from starfish.experiment.builder import FetchedTile, TileFetcher
from starfish.experiment.builder import write_experiment_json
from starfish.types import Axes, Coordinates

s3_bucket = "s3://spacetx.starfish.data.output/iss/formatted/"

```

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

### Enable Qt and display data with starfish display()

Source: https://spacetx-starfish.readthedocs.io/en/latest/_downloads/aec98be7c09c9fe185bf42b00bff51fd/plot_display.ipynb

Run '%gui qt' to enable the Qt event loop in IPython, then call display() with stack, spots, and masks parameters to open a napari Viewer window showing the provided data.

```python
>>> %gui qt
>>> display(stack=registered_imgs, spots=decoded, masks=masks)
```

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

### Manifest JSON example

Source: https://spacetx-starfish.readthedocs.io/en/latest/help_and_reference/spacetx-format/SpaceTxFormat/index.html

Example of a primary images manifest with three fields of view. It associates field of view names with their JSON files.

```json
{
  "version": "0.0.0",
  "contents": {
    "fov_000": "primary-images-fov_000.json",
    "fov_001": "primary-images-fov_001.json",
    "fov_00N": "primary-images-fov_002.json"
  },
  "extras": null
}
```

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

### Configure and run three FindSpotsAlgorithm on cropped images

Source: https://spacetx-starfish.readthedocs.io/en/latest/gallery/tutorials/spotbased_decoding.html

Instantiates BlobDetector, LocalMaxPeakFinder, and TrackpyLocalMaxPeakFinder with tuned parameters, crops the image stacks, runs each spot finder, and builds spot traces into intensity tables. The parameters are roughly tuned and may not reflect best performance.

```python
bd = FindSpots.BlobDetector(
    min_sigma=2,
    max_sigma=6,
    num_sigma=20,
    threshold=0.1,
    is_volume=True,
    measurement_type='mean',
)

lmp = FindSpots.LocalMaxPeakFinder(
    min_distance=2,
    stringency=8,
    min_obj_area=6,
    max_obj_area=600,
    is_volume=True
)

tlmpf = FindSpots.TrackpyLocalMaxPeakFinder(
    spot_diameter=11,
    min_mass=0.2,
    max_size=8,
    separation=3,
    preprocess=False,
    percentile=80,
    verbose=True,
)

# crop imagestacks
crop_selection = {Axes.X: (300, 700), Axes.Y: (300, 700)}
cropped_imgs= imgs.sel(crop_selection)
cropped_dots = dots.sel(crop_selection)

# find spots on cropped images
bd_spots = bd.run(image_stack=cropped_imgs, reference_image=cropped_dots)
lmp_spots = lmp.run(image_stack=cropped_imgs, reference_image=cropped_dots)
tlmpf_spots = tlmpf.run(image_stack=cropped_imgs, reference_image=cropped_dots)

# build spot traces into intensity table
bd_table = build_spot_traces_exact_match(bd_spots)
lmp_table = build_spot_traces_exact_match(lmp_spots)
tlmpf_table = build_spot_traces_exact_match(tlmpf_spots)

```

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

### Initialize and run DecodeSpots.PerRoundMaxChannel

Source: https://spacetx-starfish.readthedocs.io/en/latest/_downloads/3f9b3bf8c45732b088faf9632d5aa18b/starmap_pipeline.ipynb

Initializes the decoder with a codebook and trace building strategy, then runs it on the provided spots to generate a decoded result.

```python
from starfish.spots import DecodeSpots
from starfish.types import TraceBuildingStrategies

decoder = DecodeSpots.PerRoundMaxChannel(
    codebook=experiment.codebook,
    anchor_round=0,
    search_radius=10,
    trace_building_strategy=TraceBuildingStrategies.NEAREST_NEIGHBOR)

decoded = decoder.run(spots=spots)

decode_mask = decoded['target'] != 'nan'
```

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

### Experiment JSON example

Source: https://spacetx-starfish.readthedocs.io/en/latest/help_and_reference/spacetx-format/SpaceTxFormat/index.html

Example of the Experiment JSON file that ties together image manifests and codebook. It is read by starfish to load data into the analysis environment.

```json
{
  "version": "0.0.0",
  "images": {
    "primary": "primary_images.json",
    "nuclei": "nuclei.json"
  },
  "codebook": "codebook.json",
  "extras": {
    "is_space_tx_cool": true
  }
}
```

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

### Initialize StarMap Tile Fetchers and Write Experiment Metadata

Source: https://spacetx-starfish.readthedocs.io/en/latest/_downloads/1d0e81f05b770e1922ea98fcf2e8e650/format_starmap.ipynb

This script sets up tile fetchers for primary and auxiliary images, defines image dimensions, and writes the experiment configuration to a JSON file.

```python
    abs_output_dir = os.path.expanduser(output_dir)
    abs_input_dir = os.path.expanduser(input_dir)
    os.makedirs(abs_output_dir, exist_ok=True)

    primary_tile_fetcher = StarMapTileFetcher(abs_input_dir)
    dapi_tile_fetcher = StarMapDapiTileFetcher(abs_input_dir)
    nissl_00_tile_fetcher = StarMapNisslTileFetcher(abs_input_dir, channels=(0, 0))
    nissl_01_tile_fetcher = StarMapNisslTileFetcher(abs_input_dir, channels=(0, 1))
    nissl_02_tile_fetcher = StarMapNisslTileFetcher(abs_input_dir, channels=(0, 2))

    # This is hardcoded for this example data set
    primary_image_dimensions: Mapping[Union[str, Axes], int] = {
        Axes.ROUND: 6,
        Axes.CH: 4,
        Axes.ZPLANE: 28,
    }

    aux_images_dimensions: Mapping[str, Mapping[Union[str, Axes], int]] = {
        "nuclei": {
            Axes.ROUND: 1,
            Axes.CH: 1,
            Axes.ZPLANE: 1,
        },
        "nissl_channels_0_0": {
            Axes.ROUND: 1,
            Axes.CH: 1,
            Axes.ZPLANE: 1,
        },
        "nissl_channels_0_1": {
            Axes.ROUND: 1,
            Axes.CH: 1,
            Axes.ZPLANE: 1,
        },
        "nissl_channels_0_2": {
            Axes.ROUND: 1,
            Axes.CH: 1,
            Axes.ZPLANE: 1,
        },
    }

    write_experiment_json(
        path=output_dir,
        fov_count=1,
        tile_format=ImageFormat.TIFF,
        primary_image_dimensions=primary_image_dimensions,
        aux_name_to_dimensions=aux_images_dimensions,
        primary_tile_fetcher=primary_tile_fetcher,
        aux_tile_fetcher={
            "nuclei": dapi_tile_fetcher,
            "nissl_channels_0_0": nissl_00_tile_fetcher,
            "nissl_channels_0_1": nissl_01_tile_fetcher,
            "nissl_hcannels_0_2": nissl_02_tile_fetcher
        },
        dimension_order=(Axes.ROUND, Axes.CH, Axes.ZPLANE)
    )

    primary_tile_fetcher.generate_codebook(abs_output_dir)


if __name__ == "__main__":
    cli()
```

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

### Install Starfish for development with make install-dev

Source: https://spacetx-starfish.readthedocs.io/en/latest/developer_guide/index.html

Installs Starfish in development mode using the Makefile target 'install-dev'. This should be run after cloning the repository and setting up a virtual environment.

```bash
$ make install-dev

```

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

### Create virtual environment with venv

Source: https://spacetx-starfish.readthedocs.io/en/latest/installation/index.html

Create a work folder and set up a virtual environment using Python's venv module. Recommended to avoid dependency conflicts.

```bash
$ mkdir starfish
$ cd starfish
$ python -m venv .venv
$ source .venv/bin/activate

```

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

### Progress bar output

Source: https://spacetx-starfish.readthedocs.io/en/latest/gallery/tutorials/plot_image_manipulations.html

Example of the progress bar output displayed during processing.

```text
  0%|          | 0/4 [00:00<?, ?it/s]
100%|██████████| 4/4 [00:00<00:00, 804.12it/s]
```

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

### Import DecodeSpots

Source: https://spacetx-starfish.readthedocs.io/en/latest/api/spots/index.html

Import the DecodeSpots class to access spot decoding algorithms.

```python
from starfish.spots import DecodeSpots
```

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

### Upgrade Starfish via PyPI

Source: https://spacetx-starfish.readthedocs.io/en/latest/developer_guide/index.html

Use this command to upgrade the Starfish package when installed from PyPI.

```bash
pip install --upgrade starfish
```

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

### Interactive spot visualization with napari (commented out)

Source: https://spacetx-starfish.readthedocs.io/en/latest/_downloads/169902c1926194d73770b29c9678388a/spotbased_decoding.ipynb

Shows how to view the multi-dimensional spot finding results interactively with napari. The code is commented out and requires uncommenting the lines and enabling the Qt GUI with %gui qt. It displays the cropped dots stack with each spot table.

```python
# uncomment to view with napari
# %gui qt
# BlobDetector
# viewer = display(stack=cropped_dots, spots=bd_table)

# LocalMaxPeakFinder
# display(stack=cropped_dots, spots=lmp_table)

# TrackpyLocalMaxPeakFinder
# display(stack=cropped_dots, spots=tlmpf_table)
```

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

### Run write_experiment_json()

Source: https://spacetx-starfish.readthedocs.io/en/latest/gallery/data_formatting/plot_format_tilefetcher.html

This code calls write_experiment_json() with the required parameters: a TileFetcher instance, the output path, and a primary image dimension. It constructs the necessary parameters based on the fovs, rounds, channels, and zplanes of the example data.

```python
from starfish.experiment.builder import write_experiment_json

# calculate dimensions based on fovs, rounds, channels, zplanes
# omitted for brevity
write_experiment_json(fetcher, path, primary_image_dimension)

```

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

### Define recipe.py processing method

Source: https://spacetx-starfish.readthedocs.io/en/latest/user_guide/processing_at_scale/index.html

Example implementation of the process_fov method for processing a single field of view.

```python
from starfish import Codebook, DecodedIntensityTable, FieldOfView
from starfish.image import ApplyTransform, Filter, LearnTransform
from starfish.spots import DecodeSpots, FindSpots
from starfish.types import Axes, FunctionSource


def process_fov(fov: FieldOfView, codebook: Codebook) -> DecodedIntensityTable:
    """Process a single field of view of ISS data
    Parameters
    ----------
    fov : FieldOfView
        the field of view to process
    codebook : Codebook
        the Codebook to use for decoding

    Returns
    -------
    DecodedSpots :
        tabular object containing the locations of detected spots.
    """

    # note the structure of the 5D tensor containing the raw imaging data
    imgs = fov.get_image(FieldOfView.PRIMARY_IMAGES)
    dots = fov.get_image("dots")
    nuclei = fov.get_image("nuclei")

    print("Learning Transform")
    learn_translation = LearnTransform.Translation(reference_stack=dots, axes=Axes.ROUND, upsampling=1000)
    transforms_list = learn_translation.run(imgs.reduce({Axes.CH, Axes.ZPLANE}, func="max"))

    print("Applying transform")
    warp = ApplyTransform.Warp()
    registered_imgs = warp.run(imgs, transforms_list=transforms_list, verbose=True)

    print("Filter WhiteTophat")
    filt = Filter.WhiteTophat(masking_radius=15, is_volume=False)

    filtered_imgs = filt.run(registered_imgs, verbose=True)
    filt.run(dots, verbose=True, in_place=True)
    filt.run(nuclei, verbose=True, in_place=True)

    print("Detecting")
    detector = FindSpots.BlobDetector(
        min_sigma=1,
        max_sigma=10,
        num_sigma=30,
        threshold=0.01,
        measurement_type='mean',
    )
    dots_max = dots.reduce((Axes.ROUND, Axes.ZPLANE), func="max", module=FunctionSource.np)
    spots = detector.run(image_stack=filtered_imgs, reference_image=dots_max)

    print("Decoding")
    decoder = DecodeSpots.PerRoundMaxChannel(codebook=codebook)
    decoded = decoder.run(spots=spots)
    return decoded
```

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

### Richardson-Lucy Deconvolution Example

Source: https://spacetx-starfish.readthedocs.io/en/latest/api/image/index.html

Demonstrates the use of skimage and scipy to perform Richardson-Lucy deconvolution on a camera image.

```python
>>> from skimage import color, data, restoration
>>> camera = color.rgb2gray(data.camera())
>>> from scipy.signal import convolve2d
>>> psf = np.ones((5, 5)) / 25
>>> camera = convolve2d(camera, psf, 'same')
>>> camera += 0.1 * camera.std() * np.random.standard_normal(camera.shape)
>>> deconvolved = restoration.richardson_lucy(camera, psf, 5)
```

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

### Build spot traces with EXACT_MATCH strategy

Source: https://spacetx-starfish.readthedocs.io/en/latest/_downloads/329fa2a46456fe7d4624e07b17287efe/tracebuildingstrategies.ipynb

Builds spot traces using the EXACT_MATCH strategy, which requires a reference image. The output shows intensity values for each round and channel.

```python
from starfish.core.spots.DecodeSpots.trace_builders import build_spot_traces_exact_match, \
    build_traces_sequential, build_traces_nearest_neighbors

print('Build trace with EXACT_MATCH')
print(build_spot_traces_exact_match(spots_from_ref))
```

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

### Configure and run spot finders, build tables, and plot results

Source: https://spacetx-starfish.readthedocs.io/en/latest/_downloads/169902c1926194d73770b29c9678388a/spotbased_decoding.ipynb

Sets up three starfish spot finders (BlobDetector, LocalMaxPeakFinder, TrackpyLocalMaxPeakFinder), crops the image stacks, runs each finder, builds spot traces, and plots the detected spots on a cropped region. Requires starfish and matplotlib. The plot overlays spots as red circles on max-projected images.

```python
bd = FindSpots.BlobDetector(
    min_sigma=2,
    max_sigma=6,
    num_sigma=20,
    threshold=0.1,
    is_volume=True,
    measurement_type='mean',
)

lmp = FindSpots.LocalMaxPeakFinder(
    min_distance=2,
    stringency=8,
    min_obj_area=6,
    max_obj_area=600,
    is_volume=True
)

tlmpf = FindSpots.TrackpyLocalMaxPeakFinder(
    spot_diameter=11,
    min_mass=0.2,
    max_size=8,
    separation=3,
    preprocess=False,
    percentile=80,
    verbose=True,
)

# crop imagestacks
crop_selection = {Axes.X: (300, 700), Axes.Y: (300, 700)}
cropped_imgs= imgs.sel(crop_selection)
cropped_dots = dots.sel(crop_selection)

# find spots on cropped images
bd_spots = bd.run(image_stack=cropped_imgs, reference_image=cropped_dots)
lmp_spots = lmp.run(image_stack=cropped_imgs, reference_image=cropped_dots)
tlmpf_spots = tlmpf.run(image_stack=cropped_imgs, reference_image=cropped_dots)

# build spot traces into intensity table
bd_table = build_spot_traces_exact_match(bd_spots)
lmp_table = build_spot_traces_exact_match(lmp_spots)
tlmpf_table = build_spot_traces_exact_match(tlmpf_spots)

# plot spots found
import matplotlib
import matplotlib.pyplot as plt

# get x, y coords and spot size from intensity table
def get_cropped_coords(table, x_min, x_max, y_min, y_max):
    df = table.to_features_dataframe()
    df = df.loc[df['x'].between(x_min, x_max) & df['y'].between(y_min, y_max)]
    return df['x'].values-x_min, df['y'].values-y_min, df['radius'].values.astype(int)
bd_x, bd_y, bd_s = get_cropped_coords(bd_table, 200, 250, 200, 250)
lmp_x, lmp_y, lmp_s = get_cropped_coords(lmp_table, 200, 250, 200, 250)
tlmpf_x, tlmpf_y, tlmpf_s = get_cropped_coords(tlmpf_table, 200, 250, 200, 250)

matplotlib.rcParams["figure.dpi"] = 150
f, (ax1, ax2, ax3) = plt.subplots(ncols=3)

# Plot cropped region of max z-projected dots image
imshow_plane(cropped_dots.reduce({Axes.ZPLANE}, func="max"), sel={Axes.X: (200, 250), Axes.Y: (200, 250)}, ax=ax1, title='BlobDetector')
imshow_plane(cropped_dots.reduce({Axes.ZPLANE}, func="max"), sel={Axes.X: (200, 250), Axes.Y: (200, 250)}, ax=ax2, title='LocalMaxPeak')
imshow_plane(cropped_dots.reduce({Axes.ZPLANE}, func="max"), sel={Axes.X: (200, 250), Axes.Y: (200, 250)}, ax=ax3, title='Trackpy')
# Overlay spots found by each FindSpotsAlgorithm
ax1.scatter(bd_x, bd_y, marker='o', facecolors='none', edgecolors='r', s=bd_s*10)
ax2.scatter(lmp_x, lmp_y, marker='o', facecolors='none', edgecolors='r', s=lmp_s*10)
ax3.scatter(tlmpf_x, tlmpf_y, marker='o', facecolors='none', edgecolors='r', s=tlmpf_s*10)
```

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

### Disable caching in ~/.starfish.config

Source: https://spacetx-starfish.readthedocs.io/en/latest/_modules/starfish/core/config.html

Example configuration file content to disable caching by setting the size_limit to 0.

```json
{
    "slicedimage": {
        "caching": {
            "size_limit": 0
        }
    }
}
```

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

### Set validation strict via JSON configuration

Source: https://spacetx-starfish.readthedocs.io/en/latest/help_and_reference/configuration/index.html

Example JSON configuration that sets strict validation to true.

```json
{
    "validation": {
        "strict": true
    }
}

```

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

### Clone Starfish repository and enter directory

Source: https://spacetx-starfish.readthedocs.io/en/latest/developer_guide/index.html

Clones the Starfish repository from GitHub and changes into the starfish directory. This is the first step in setting up a development environment.

```bash
$ git clone git://github.com/spacetx/starfish.git
$ cd starfish

```

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

### Example Validation UserWarning

Source: https://spacetx-starfish.readthedocs.io/en/latest/api/validation/index.html

A sample warning message showing a missing required property error during schema validation.

```text
starfish/starfish/core/spacetx_format/util.py:82: UserWarning:
 'contents' is a required property
        Schema:                 https://github.com/spacetx/starfish/starfish/file-format/schema/fov-manifest.json
        Subschema level:        0
        Path to error:          required
        Filename:               ../field_of_view/field_of_view.json

  warnings.warn(message)
```

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

### Visualize spots by accessing SpotAttributes and adding points to napari viewer

Source: https://spacetx-starfish.readthedocs.io/en/latest/gallery/how_to/assess_spotfindingresults.html

Shows how to add detected spots as points to a napari viewer using the SpotAttributes from the SpotFindingResults. The code is commented out and requires the %gui qt magic command to be uncommented. Since spots were found using a reference image, the SpotAttributes are the same for every ImageSlice.

```python
# uncomment code to view
# %gui qt
# viewer = display(stack=dots)
# viewer.add_points(data=spots[{Axes.CH:1, Axes.ROUND:0}].spot_attrs.data[['z', 'y',
# 'x']].to_numpy(), size=5)

```

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

### Directory contents output

Source: https://spacetx-starfish.readthedocs.io/en/latest/gallery/data_formatting/plot_format_structured_data.html

Example output of the directory listing script, showing the files in the primary and nuclei directories.

```text
coordinates.csv
primary-f0-r0-c0-z0.tiff
primary-f0-r0-c0-z1.tiff
primary-f0-r0-c0-z2.tiff
primary-f0-r1-c0-z0.tiff
primary-f0-r1-c0-z1.tiff
primary-f0-r1-c0-z2.tiff
primary-f1-r0-c0-z0.tiff
primary-f1-r0-c0-z1.tiff
primary-f1-r0-c0-z2.tiff
primary-f1-r1-c0-z0.tiff
primary-f1-r1-c0-z1.tiff
primary-f1-r1-c0-z2.tiff


coordinates.csv
nuclei-f0-r0-c0-z0.tiff
nuclei-f0-r0-c0-z1.tiff
nuclei-f0-r0-c0-z2.tiff
nuclei-f0-r1-c0-z0.tiff
nuclei-f0-r1-c0-z1.tiff
nuclei-f0-r1-c0-z2.tiff
nuclei-f1-r0-c0-z0.tiff
nuclei-f1-r0-c0-z1.tiff
nuclei-f1-r0-c0-z2.tiff
nuclei-f1-r1-c0-z0.tiff
nuclei-f1-r1-c0-z1.tiff
nuclei-f1-r1-c0-z2.tiff

```

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

### Apply Divide Function with Filter.Map

Source: https://spacetx-starfish.readthedocs.io/en/latest/api/image/index.html

This example shows how to use Filter.Map to apply a division operation to a synthetic image stack.

```python
>>> from starfish.core.imagestack.test.factories.synthetic_stack import synthetic_stack
>>> from starfish.image import Filter
>>> from starfish.types import Axes
>>> stack = synthetic_stack()
>>> divider = Filter.Map("divide", 4)
>>> by_four = divider.run(stack)
```

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

### FindSpotsAlgorithm.run()

Source: https://spacetx-starfish.readthedocs.io/en/latest/api/index.html

Runs the FindSpotsAlgorithm to find spots in an image.

```APIDOC
## FindSpotsAlgorithm.run() n
### Description
Runs the FindSpotsAlgorithm to find spots in an image.

### Method
run() n
### Parameters
None documented.

### Returns
Found spots.
```
Tokens:
Raw