Function table_idx_from_labels has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

def table_idx_from_labels(labels):
    """Return an array of indexes into a morphology lookup table
    labels - a labels matrix
    
    returns a matrix of values between 0 and 511 of indices appropriate

• Read up
  Read up

Function slow_augmenting_row_reduction has 10 arguments (exceeds 4 allowed). Consider refactoring.

Open

def slow_augmenting_row_reduction(n, ii, jj, idx, count, x, y, u, v, c):

Function get_threshold has 10 arguments (exceeds 4 allowed). Consider refactoring.

Open

def get_threshold(

Function slow_augment has 10 arguments (exceeds 4 allowed). Consider refactoring.

Open

def slow_augment(n, ii, jj, idx, count, x, y, u, v, c):

Function convex_hull_ijv has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

def convex_hull_ijv(pixel_labels, indexes, fast=True):
    """Return the convex hull for each label using an ijv labeling
    
    pixel_labels: the labeling of the pixels in i,j,v form where
                  i & j are the coordinates of a pixel and v is

• Read up
  Read up

Function __init__ has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def __init__(self, image, labels, scale_i, scale_j, nlevels=8, mask=None):
        """
        image   -- 2-D numpy array of 32-bit floating-point numbers.
        labels  -- 2-D numpy array of integers.
        scale   -- an integer.

Function grey_reconstruction has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

def grey_reconstruction(image, mask, footprint=None, offset=None):
    """Perform a morphological reconstruction of the image
    
    grey_dilate the image, constraining each pixel to have a value that is
    at most that of the mask.

Function gabor has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

def gabor(image, labels, frequency, theta):
    """Gabor-filter the objects in an image

    image - 2-d grayscale image to filter
    labels - a similarly shaped labels matrix

Function cooccurrence has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

def cooccurrence(quantized_image, labels, scale_i=3, scale_j=0):
    """Calculates co-occurrence matrices for all the objects in the image.

    Return an array P of shape (nobjects, nlevels, nlevels) such that
    P[o, :, :] is the cooccurence matrix for object o.

• Read up
  Read up

Function __init__ has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def __init__(
        self,
        observation_matrix,
        translation_matrix,
        state_vec=None,

• Read up
  Read up

Function slow_augmenting_row_reduction has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

def slow_augmenting_row_reduction(n, ii, jj, idx, count, x, y, u, v, c):
    """Perform the augmenting row reduction step from the Jonker-Volgenaut algorithm
    
    n - the number of i and j in the linear assignment problem
    ii - the unassigned i

• Read up
  Read up

Function get_global_threshold has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

def get_global_threshold(threshold_method, image, mask=None, **kwargs):
    """Compute a single threshold over the whole image"""
    if mask is not None and not np.any(mask):
        return 1

• Read up
  Read up

Function find_neighbors has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

def find_neighbors(labels):
    """Find the set of objects that touch each object in a labels matrix
    
    Construct a "list", per-object, of the objects 8-connected adjacent
    to that object.

Function is_local_maximum has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

def is_local_maximum(image, labels, footprint):
    """Return a boolean array of points that are local maxima
    
    image - intensity image
    labels - find maxima only within labels. Zero is reserved for background.

Function get_mog_threshold has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

def get_mog_threshold(image, mask=None, object_fraction=0.2):
    """Compute a background using a mixture of gaussians
    
    This function finds a suitable
    threshold for the input image Block. It assumes that the pixels in the

Function zernike has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

def zernike(zernike_indexes, labels, indexes):
    """Compute the Zernike features for the labels with the label #s in indexes
    
    returns the score per labels and an array of one image per zernike feature
    """

Function otsu3 has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

def otsu3(data, min_threshold=None, max_threshold=None, bins=128):
    """Compute a threshold using a 3-category Otsu-like method
    
    data           - an array of intensity values between zero and one
    min_threshold  - only consider thresholds above this minimum value

Function get_per_object_threshold has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

def get_per_object_threshold(

Function backgr has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

def backgr(

Function slow_reduction_transfer has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

def slow_reduction_transfer(ii, j, idx, count, x, u, v, c):