Source code for allensdk.mouse_connectivity.grid.subimage.classic_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, IntensitySubImage


#==============================================================================


[docs]class ClassicSubImage(IntensitySubImage, SegmentationSubImage, PolygonSubImage):
    
    required_polys = ['missing_tile', 'no_signal', 'aav_exclusion']
    optional_polys = ['aav_tracer']
    required_segmentations = ['segmentation']
    required_intensities = ['green']
    
    
    def __init__(self, reduce_level, in_dims, in_spacing, coarse_spacing, 
                 polygon_info, segmentation_paths, intensity_paths,
                 injection_polygon_key='aav_tracer', 
                 *args, **kwargs):
                 
        super(ClassicSubImage, self).__init__(
            reduce_level, in_dims, in_spacing, coarse_spacing, 
            polygon_info=polygon_info, 
            segmentation_paths=segmentation_paths, 
            intensity_paths=intensity_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:
            logging.info('reading injection from rasterized {} polygon'.format(self.injection_polygon_key))
            self.images['injection'] = self.images[self.injection_polygon_key]
            del self.images[self.injection_polygon_key]
        else:
            self.extract_injection_from_segmentation()
        del self.images['segmentation']
        logging.info('injection pixel count: {}'.format(np.count_nonzero(self.images['injection'])))
        
        self.binarize('projection')
        self.binarize('injection')
        
        
[docs]    def compute_coarse_planes(self):

        #  do these in batches to minimize peak memory usage
        self.compute_intensity()
        self.compute_injection()
        self.compute_projection()
        self.compute_sum_pixels()
        
        del self.images
        

[docs]    def compute_intensity(self):
        logging.info('computing green accumulators')
                
        self.apply_pixel_counter('sum_pixel_intensities', self.images['green'])

        injection_intensity = np.multiply(self.images['green'], self.images['injection'])
        self.apply_pixel_counter('injection_sum_pixel_intensities', injection_intensity)
        del injection_intensity
        
        self.images['green'][self.images['projection'] == 0] = 0
        self.apply_pixel_counter('sum_projecting_pixel_intensities', self.images['green'])
        
        self.images['green'][self.images['injection'] == 0] = 0
        self.apply_pixel_counter('injectionsum_projecting_pixel_intensities', self.images['green'])

        del self.images['green']    


[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'])


#==============================================================================
Source code for allensdk.mouse_connectivity.grid.subimage.classic_subimage

Contents

Questions
