Firing field analysis¶

The following properties can be accessed as attributes or keys:

area : float Area of the region i.e. number of pixels of the region scaled by pixel-area.

area_bbox : float Area of the bounding box i.e. number of pixels of bounding box scaled by pixel-area.

area_convex : float Area of the convex hull image, which is the smallest convex polygon that encloses the region.

area_filled : float Area of the region with all the holes filled in.

axis_major_length : float The length of the major axis of the ellipse that has the same normalized second central moments as the region.

axis_minor_length : float The length of the minor axis of the ellipse that has the same normalized second central moments as the region.

bbox : tuple Bounding box (min_row, min_col, max_row, max_col). Pixels belonging to the bounding box are in the half-open interval [min_row; max_row) and [min_col; max_col).

centroid : array Centroid coordinate tuple (row, col).

centroid_local : array Centroid coordinate tuple (row, col), relative to region bounding box.

centroid_weighted : array Centroid coordinate tuple (row, col) weighted with intensity image.

centroid_weighted_local : array Centroid coordinate tuple (row, col), relative to region bounding box, weighted with intensity image.

coords_scaled : (K, 2) ndarray Coordinate list (row, col) of the region scaled by spacing.

coords : (K, 2) ndarray Coordinate list (row, col) of the region.

eccentricity : float Eccentricity of the ellipse that has the same second-moments as the region. The eccentricity is the ratio of the focal distance (distance between focal points) over the major axis length. The value is in the interval [0, 1). When it is 0, the ellipse becomes a circle.

equivalent_diameter_area : float The diameter of a circle with the same area as the region.

euler_number : int Euler characteristic of the set of non-zero pixels. Computed as number of connected components subtracted by number of holes (input.ndim connectivity). In 3D, number of connected components plus number of holes subtracted by number of tunnels.

extent : float Ratio of pixels in the region to pixels in the total bounding box. Computed as area / (rows cols)

feret_diameter_max : float Maximum Feret's diameter computed as the longest distance between points around a region's convex hull contour as determined by find_contours. [5]_

image : (H, J) ndarray Sliced binary region image which has the same size as bounding box.

image_convex : (H, J) ndarray Binary convex hull image which has the same size as bounding box.

image_filled : (H, J) ndarray Binary region image with filled holes which has the same size as bounding box.

image_intensity : ndarray Image inside region bounding box.

inertia_tensor : ndarray Inertia tensor of the region for the rotation around its mass.

inertia_tensor_eigvals : tuple The eigenvalues of the inertia tensor in decreasing order.

intensity_max : float Value with the greatest intensity in the region.

intensity_mean : float Value with the mean intensity in the region.

intensity_min : float Value with the least intensity in the region.

intensity_std : float Standard deviation of the intensity in the region.

label : int The label in the labeled input image.

moments : (3, 3) ndarray Spatial moments up to 3^rd order::

    m_ij = sum{ array(row, col)  row^i  col^j }

where the sum is over the `row`, `col` coordinates of the region.

moments_central : (3, 3) ndarray Central moments (translation invariant) up to 3^rd order::

    mu_ij = sum{ array(row, col)  (row - row_c)^i  (col - col_c)^j }

where the sum is over the `row`, `col` coordinates of the region,
and `row_c` and `col_c` are the coordinates of the region's centroid.

moments_hu : tuple Hu moments (translation, scale and rotation invariant).

moments_normalized : (3, 3) ndarray Normalized moments (translation and scale invariant) up to 3^rd order::

    nu_ij = mu_ij / m_00^[(i+j)/2 + 1]

where `m_00` is the zeroth spatial moment.

moments_weighted : (3, 3) ndarray Spatial moments of intensity image up to 3^rd order::

    wm_ij = sum{ array(row, col)  row^i  col^j }

where the sum is over the `row`, `col` coordinates of the region.

moments_weighted_central : (3, 3) ndarray Central moments (translation invariant) of intensity image up to 3^rd order::

    wmu_ij = sum{ array(row, col)  (row - row_c)^i  (col - col_c)^j }

where the sum is over the `row`, `col` coordinates of the region,
and `row_c` and `col_c` are the coordinates of the region's weighted
centroid.

moments_weighted_hu : tuple Hu moments (translation, scale and rotation invariant) of intensity image.

moments_weighted_normalized : (3, 3) ndarray Normalized moments (translation and scale invariant) of intensity image up to 3^rd order::

    wnu_ij = wmu_ij / wm_00^[(i+j)/2 + 1]

where ``wm_00`` is the zeroth spatial moment (intensity-weighted area).

num_pixels : int Number of foreground pixels.

orientation : float Angle between the 0^th axis (rows) and the major axis of the ellipse that has the same second moments as the region, ranging from -pi/2 to pi/2 counter-clockwise.

perimeter : float Perimeter of object which approximates the contour as a line through the centers of border pixels using a 4-connectivity.

perimeter_crofton : float Perimeter of object approximated by the Crofton formula in 4 directions.

slice : tuple of slices A slice to extract the object from the source image.

solidity : float Ratio of pixels in the region to pixels of the convex hull image.

Each region also supports iteration, so that you can do::

for prop in region: print(prop, region[prop])

In the default case will sort by area, largest first

this modifies the input list

This is a simple method to partition fields that only returns a single field - the one with the highest mean firing rate.

See Hinman et al., 2019 for more details

See Hinman et al., 2019 for more details

See Hinman et al., 2019 for more details

If the cell is a border cell (BVC) then we know that it should fire at a fixed distance from a given boundary (possibly more than one). In essence this algorithm estimates the amount of variance in this distance i.e. if the cell is a border cell this number should be small. This is achieved by first doing a bunch of morphological operations to isolate individual fields in the ratemap (similar to the code used in phasePrecession.py - see the fancy_partition method therein). These partitioned fields are then thinned out (using skimage's skeletonize) to a single pixel wide field which will lie more or less in the middle of the (highly smoothed) sub-field. It is the variance in distance from the nearest boundary along this pseudo-iso-line that is the boundary measure

Other things to note are that the pixel-wide field has to have some minimum length. In the case of a circular environment this is set to 20% of the circumference; in the case of a square environment markers this is at least half the length of the longest side

The Kullback-Leibler divergence is given by:

.. math:: KL(P1(x),P2(x)) = sum_[P1(x).log(P1(x)/P2(x))]

If X contains duplicate values, there will be an warning message, and these values will be treated as distinct values. (I.e., the actual values do not enter into the computation, but the probabilities for the two duplicate values will be considered as probabilities corresponding to two unique values.). The elements of probability vectors P1 and P2 must each sum to 1 ± .00001.

This function is taken from one on the Mathworks file exchange

The ratemap data should have undergone adaptive binning as per the original paper. See getAdaptiveMap() in binning class

The estimate of spatial information in bits per spike:

.. math:: I = sum_{x} p(x).r(x).log(r(x)/r)

The output from this method can be used as input to the show() method of this class. When it is the plot produced will display a lot more informative. The coordinate system internally used is centred on the image centre.

The correlation performed is a Pearsons R. Some rescaling of the values in image is performed following rotation.