Ejemplo n.º 1
0
def test_apply_labeled_dataset():
    """
    test that apply correctly applies a simple function across starfish-generated synthetic data
    """
    original = SyntheticData().spots()
    image = original.apply(divide, value=2)
    assert np.all(image.xarray == original.xarray / 2)
Ejemplo n.º 2
0
def test_apply_in_place():
    """
    test that apply correctly applies a simple function across a starfish stack without modifying
    original data
    """
    image = SyntheticData().spots()
    original = copy.deepcopy(image)
    image.apply(divide, value=2, in_place=True)
    assert np.all(image.xarray == original.xarray / 2)
Ejemplo n.º 3
0
def test_fov_order():
    data = SyntheticData()
    codebook = data.codebook()
    tilesets = {"primary": get_aligned_tileset()}
    fovs = [FieldOfView("stack2", tilesets), FieldOfView("stack1", tilesets)]
    extras = {"synthetic": True}
    experiment = Experiment(fovs, codebook, extras)
    assert "stack1" == experiment.fov().name
    assert ["stack1", "stack2"] == [x.name for x in experiment.fovs()]
Ejemplo n.º 4
0
def test_medium_synthetic_stack():
    np.random.seed(0)

    n_z = 40
    height = 300
    width = 400
    sigma = 2

    sd = SyntheticData(
        n_round=4,
        n_ch=4,
        n_z=n_z,
        height=height,
        width=width,
        n_spots=100,
        n_codes=10,
        point_spread_function=(sigma, sigma, sigma),
    )

    codebook = sd.codebook()
    intensities = sd.intensities(codebook=codebook)

    # some spots won't be detected properly because they will spread outside the image where
    # blurred,
    # so we'll remove those from intensities before we generate spots.

    spot_radius = sigma * np.sqrt(
        2)  # this is the radius of the spot in pixels

    valid_z = np.logical_and(intensities.z.values > spot_radius,
                             intensities.z.values < (n_z - spot_radius))
    valid_y = np.logical_and(intensities.y.values > spot_radius,
                             intensities.y.values < (height - spot_radius))
    valid_x = np.logical_and(intensities.x.values > spot_radius,
                             intensities.x.values < (width - spot_radius))

    valid_locations = valid_z & valid_y & valid_x
    intensities = intensities[np.where(valid_locations)]
    spots = sd.spots(intensities=intensities)
    gsd = BlobDetector(min_sigma=1, max_sigma=4, num_sigma=5, threshold=1e-4)
    spots_max_projector = Filter.Reduce((Axes.ROUND, Axes.CH),
                                        func="max",
                                        module=FunctionSource.np)
    spots_max = spots_max_projector.run(spots)
    spot_results = gsd.run(image_stack=spots, reference_image=spots_max)

    decoder = DecodeSpots.MetricDistance(codebook=codebook,
                                         max_distance=1,
                                         min_intensity=0,
                                         norm_order=2)
    decoded_intensities = decoder.run(spots=spot_results)
    assert len(decoded_intensities.coords[Features.TARGET]) == 80
Ejemplo n.º 5
0
def test_metric_decoder_original_intensities_flag():
    np.random.seed(0)

    n_z = 40
    height = 300
    width = 400
    sigma = 2

    sd = SyntheticData(
        n_round=4,
        n_ch=4,
        n_z=n_z,
        height=height,
        width=width,
        n_spots=100,
        n_codes=10,
        point_spread_function=(sigma, sigma, sigma),
    )

    codebook = sd.codebook()
    intensities = sd.intensities(codebook=codebook)

    spots = sd.spots(intensities=intensities)
    gsd = BlobDetector(min_sigma=1, max_sigma=4, num_sigma=5, threshold=1e-4)
    spots_max_projector = Filter.Reduce((Axes.ROUND, Axes.CH),
                                        func=FunctionSource.np("max"))
    spots_max = spots_max_projector.run(spots)
    spot_results = gsd.run(image_stack=spots, reference_image=spots_max)

    og_intensities = build_spot_traces_exact_match(spot_results=spot_results)

    decoder = DecodeSpots.MetricDistance(codebook=codebook,
                                         max_distance=1,
                                         min_intensity=0,
                                         norm_order=2,
                                         return_original_intensities=True)
    decoded_intensities = decoder.run(spots=spot_results)

    # assert that original intensities were returned in the decocded intensity file
    assert np.array_equal(decoded_intensities.values, og_intensities.values)

    # now run without flag, assert intensities change
    decoder = DecodeSpots.MetricDistance(codebook=codebook,
                                         max_distance=1,
                                         min_intensity=0,
                                         norm_order=2,
                                         return_original_intensities=False)
    decoded_intensities = decoder.run(spots=spot_results)

    assert not np.array_equal(decoded_intensities.values,
                              og_intensities.values)
Ejemplo n.º 6
0
def test_round_trip_synthetic_data():
    np.random.seed(0)

    sd = SyntheticData(
        n_ch=2,
        n_round=3,
        n_spots=1,
        n_codes=4,
        n_photons_background=0,
        background_electrons=0,
        camera_detection_efficiency=1.0,
        gray_level=1,
        ad_conversion_bits=16,
        point_spread_function=(2, 2, 2),
    )

    codebook = sd.codebook()
    intensities = sd.intensities(codebook=codebook)
    spots = sd.spots(intensities=intensities)
    spots_max_projector = Filter.Reduce((Axes.ROUND, Axes.CH),
                                        func="max",
                                        module=FunctionSource.np)
    spots_max = spots_max_projector.run(spots)

    gsd = BlobDetector(min_sigma=1, max_sigma=4, num_sigma=5, threshold=0)
    spot_results = gsd.run(image_stack=spots, reference_image=spots_max)

    decoder = DecodeSpots.MetricDistance(codebook=codebook,
                                         max_distance=1,
                                         min_intensity=0,
                                         norm_order=2)
    decoded_intensities = decoder.run(spots=spot_results)

    # applying the gaussian blur to the intensities causes them to be reduced in magnitude, so
    # they won't be the same size, but they should be in the same place, and decode the same
    # way
    spot1, ch1, round1 = np.where(intensities.values)
    spot2, ch2, round2 = np.where(decoded_intensities.values)
    assert np.array_equal(spot1, spot2)
    assert np.array_equal(ch1, ch2)
    assert np.array_equal(round1, round2)
    assert len(decoded_intensities.coords[Features.TARGET]) == 1
Ejemplo n.º 7
0
import numpy as np
import pytest

from starfish import BinaryMaskCollection, display, LabelImage
from starfish.core.test.factories import SyntheticData
from starfish.types import Coordinates

sd = SyntheticData(
    n_ch=2,
    n_round=3,
    n_spots=1,
    n_codes=4,
    n_photons_background=0,
    background_electrons=0,
    camera_detection_efficiency=1.0,
    gray_level=1,
    ad_conversion_bits=16,
    point_spread_function=(2, 2, 2),
)

stack = sd.spots()
spots = sd.intensities()
label_image = LabelImage.from_label_array_and_ticks(
    np.random.randint(0, 4, size=(128, 128), dtype=np.uint8),
    None,
    {
        Coordinates.Y: np.arange(128),
        Coordinates.X: np.arange(128)
    },
    None,
)