Source code for allensdk.mouse_connectivity.grid.subimage.count_subimage

from __future__ import division
import logging
import sys
import functools

import numpy as np
from scipy.ndimage.interpolation import zoom
from six import iteritems

from allensdk.mouse_connectivity.grid.utilities import image_utilities as iu
from .base_subimage import PolygonSubImage, SegmentationSubImage



[docs]class CountSubImage(SegmentationSubImage, PolygonSubImage):

    required_polys = ['missing_tile', 'no_signal', 'aav_exclusion']
    required_segmentations = ['segmentation']

    def __init__(self, reduce_level, in_dims, in_spacing, coarse_spacing,
                 polygon_info, segmentation_paths, injection_polygon_key='aav_tracer', *args, **kwargs):

        super(CountSubImage, self).__init__(reduce_level, in_dims, in_spacing,
                                                   coarse_spacing,
                                                   polygon_info=polygon_info,
                                                   segmentation_paths=segmentation_paths,
                                                   *args, **kwargs)
        self.injection_polygon_key = injection_polygon_key



[docs]    def process_segmentation(self):

        self.apply_mask('segmentation', 'missing_tile', False)

        self.extract_signal_from_segmentation(signal_name='projection')

        self.apply_mask('projection', 'no_signal', False)
        del self.images['no_signal']

        if self.injection_polygon_key in self.images:
            self.images['injection'] = self.images[self.injection_polygon_key]
            del self.images[injection_polygon_key]
        else:
            self.extract_injection_from_segmentation()        
        del self.images['segmentation']

        self.binarize('projection')
        self.binarize('injection')




[docs]    def compute_injection(self):
        logging.info('computing injection accumulators')

        self.apply_pixel_counter('injection_sum_pixels', self.images['injection'])

        injection_projecting_pixels = np.logical_and(self.images['injection'], self.images['projection'])
        self.apply_pixel_counter('injection_sum_projecting_pixels', injection_projecting_pixels)
        del injection_projecting_pixels

        del self.images['injection']




[docs]    def compute_projection(self):
        logging.info('computing projection accumulators')

        self.apply_pixel_counter('sum_projecting_pixels', self.images['projection'])
        del self.images['projection']




[docs]    def compute_sum_pixels(self):
        logging.info('computing sum pixel accumulators')

        self.apply_pixel_counter('sum_pixels', np.logical_not(self.images['missing_tile']))

        if 'aav_exclusion' in self.images:
            self.apply_pixel_counter('aav_exclusion_sum_pixels', self.images['aav_exclusion'])




[docs]    def compute_coarse_planes(self):

        self.compute_injection()
        self.compute_projection()
        self.compute_sum_pixels()

        del self.images