diff_classifier.features

Complexity

Total Complexity

46

Size/Duplication

Total Lines	745
Duplicated Lines	95.44 %

Importance

Changes

0

11 Functions

Rating	Name	Duplication	Size	Complexity
A	kurtosis()	49	49	5
B	aspectratio()	54	54	6
A	alpha_calc()	60	60	2
A	unmask_track()	39	39	1
A	msd_ratio()	47	47	2
C	minBoundingRect()	130	130	9
A	efficiency()	53	53	1
B	boundedness()	81	81	7
A	asymmetry()	61	61	5
A	gyration_tensor()	67	67	5
B	calculate_features()	70	70	3

import numpy as np

This module should have a docstring.

import pandas as pd
import numpy.ma as ma

Imports from package numpy are not grouped

from scipy.optimize import curve_fit
import numpy.linalg as LA

Imports from package numpy are not grouped

import math

standard import "import math" should be placed before "import numpy as np"

import struct

standard import "import struct" should be placed before "import numpy as np"

import sys

The import sys seems to be unused.

standard import "import sys" should be placed before "import numpy as np"

import diff_classifier.utils as ut

Unused diff_classifier.utils imported as ut

import diff_classifier.msd as msd


def unmask_track(track):

This code seems to be duplicated in your project.

    """
    Removes empty frames from a track in an MSD pandas dataframe.

    Parameters
    ----------
    track : pandas Dataframe
        At a minimum, must contain a Frame, Track_ID, X, Y, MSDs, and
        Gauss column.

    Returns
    -------
    comp_track : pandas Dataframe
        Similar to track, but has all masked components removed.

    Examples
    --------

    """
    x = ma.masked_invalid(track['X'])

The name x does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    msd = ma.masked_invalid(track['MSDs'])

msd is re-defining a name which is already available in the outer-scope (previously defined on line 11).

    x_mask = ma.getmask(x)
    msd_mask = ma.getmask(msd)
    comp_frame = ma.compressed(ma.masked_where(msd_mask, track['Frame']))
    comp_ID = ma.compressed(ma.masked_where(msd_mask, track['Track_ID']))

The name comp_ID does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    comp_x = ma.compressed(ma.masked_where(x_mask, track['X']))
    comp_y = ma.compressed(ma.masked_where(x_mask, track['Y']))
    comp_msd = ma.compressed(ma.masked_where(msd_mask, track['MSDs']))
    comp_gauss = ma.compressed(ma.masked_where(msd_mask, track['Gauss']))

    d = {'Frame': comp_frame,

The name d does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

         'Track_ID': comp_ID,
         'X': comp_x,
         'Y': comp_y,
         'MSDs': comp_msd,
         'Gauss': comp_gauss
         }

Wrong continued indentation (remove 1 space).

    comp_track = pd.DataFrame(data=d)
    return comp_track


def alpha_calc(track):

This code seems to be duplicated in your project.

    """
    Calculates the parameter alpha by fitting track MSD data to a function.

    Parameters
    ----------
    track : pandas DataFrame
        At a minimum, must contain a Frames and a MSDs column.  The function
        msd_calc can be used to generate the correctly formatted pd dataframe.

    Returns
    -------
    a : numpy.float64
        The anomalous exponent derived by fitting MSD values to the function,
        <r**2(n)> = 4*D*(n*delt)**a
    D : numpy.float64
        The fitted diffusion coefficient derived by fitting MSD values to the
        function above.

    Examples
    --------
    >>> frames = 5
    >>> d = {'Frame': np.linspace(1, frames, frames),
             'X': np.linspace(1, frames, frames)+5,
             'Y': np.linspace(1, frames, frames)+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> alpha_calc(df)
    (2.0000000000000004, 0.4999999999999999)

    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
               'X': np.sin(np.linspace(1, frames, frames)+3),
               'Y': np.cos(np.linspace(1, frames, frames)+3)}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> alpha_calc(df)
    (0.023690002018364065, 0.5144436515510022)
    """

    # assert type(track) == pd.core.frame.DataFrame, "track must be a pandas dataframe."
    # assert type(track['MSDs']) == pd.core.series.Series, "track must contain MSDs column."
    # assert type(track['Frame']) == pd.core.series.Series, "track must contain Frame column."
    # assert track.shape[0] > 0, "track must not be empty."

    y = track['MSDs']

The name y does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    x = track['Frame']

The name x does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    def msd_alpha(x, a, D):

The name x does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name a does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name D does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

This function should have a docstring.

        return 4*D*(x**a)

    try:
        popt, pcov = curve_fit(msd_alpha, x, y)

The variable pcov seems to be unused.

        a = popt[0]

The name a does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        D = popt[1]

The name D does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    except RuntimeError:
        print('Optimal parameters not found. Print NaN instead.')
        a = np.nan

The name a does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        D = np.nan

The name D does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    return a, D


def gyration_tensor(track):

This code seems to be duplicated in your project.

    """
    Calculates the eigenvalues and eigenvectors of the gyration tensor of the
    input trajectory.

    Parameters
    ----------
    track : pandas DataFrame
        At a minimum, must contain an X and Y column.  The function
        msd_calc can be used to generate the correctly formatted pd dataframe.

    Returns
    -------
    l1 : numpy.float64
        Dominant eigenvalue of the gyration tensor.
    l2 : numpy.float64
        Secondary eigenvalue of the gyration tensor.
    v1 : 2 x 1 numpy.ndarray of numpy.float64 objects
        Dominant eigenvector of the gyration tensor.
    v2 : 2 x 1 numpy.ndarray of numpy.float64 objects
        Secondary eigenvector of the gyration tensor.

    Examples
    --------
    >>> frames = 5
    >>> d = {'Frame': np.linspace(1, frames, frames),
             'X': np.linspace(1, frames, frames)+5,
             'Y': np.linspace(1, frames, frames)+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> gyration_tensor(df)
    (4.0,
    4.4408920985006262e-16,
    array([ 0.70710678, -0.70710678]),
    array([ 0.70710678,  0.70710678]))

    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
               'X': np.sin(np.linspace(1, frames, frames)+3),
               'Y': np.cos(np.linspace(1, frames, frames)+3)}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> gyration_tensor(df)
    (0.53232560128104522,
    0.42766829138901619,
    array([ 0.6020119 , -0.79848711]),
    array([-0.79848711, -0.6020119 ]))
    """

    df = track

The name df does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    assert type(df) == pd.core.frame.DataFrame, "track must be a pandas dataframe."

Using type() instead of isinstance() for a typecheck.

    assert type(df['X']) == pd.core.series.Series, "track must contain X column."

Using type() instead of isinstance() for a typecheck.

    assert type(df['Y']) == pd.core.series.Series, "track must contain Y column."

Using type() instead of isinstance() for a typecheck.

    assert df.shape[0] > 0, "track must not be empty."

    Ta = np.sum((df['X'] - np.mean(df['X']))**2)/df['X'].shape[0]

The name Ta does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    Tb = np.sum((df['Y'] - np.mean(df['Y']))**2)/df['Y'].shape[0]

The name Tb does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    Tab = np.sum((df['X'] - np.mean(df['X']))*(df['Y'] - np.mean(df['Y'])))/df['X'].shape[0]

The name Tab does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    w, v = LA.eig(np.array([[Ta, Tab], [Tab, Tb]]))

The name w does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name v does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    dom = np.argmax(np.abs(w))
    rec = np.argmin(np.abs(w))
    l1 = w[dom]

The name l1 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    l2 = w[rec]

The name l2 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    v1 = v[dom]

The name v1 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    v2 = v[rec]

The name v2 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    return l1, l2, v1, v2


def kurtosis(track):

This code seems to be duplicated in your project.

    """
    Calculates the kurtosis of input track.

    Parameters
    ----------
    track : pandas DataFrame
        At a minimum, must contain an X and Y column.  The function
        msd_calc can be used to generate the correctly formatted pd dataframe.

    Returns
    -------
    kurt : numpy.float64
        Kurtosis of the input track.  Calculation based on projected 2D positions
        on the dominant eigenvector of the radius of gyration tensor.

    Examples
    --------
    >>> frames = 5
    >>> d = {'Frame': np.linspace(1, frames, frames),
             'X': np.linspace(1, frames, frames)+5,
             'Y': np.linspace(1, frames, frames)+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> kurtosis(df)
    2.5147928994082829

    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
               'X': np.sin(np.linspace(1, frames, frames)+3),
               'Y': np.cos(np.linspace(1, frames, frames)+3)}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> kurtosis(df)
    1.8515139698652476
    """

    df = track

The name df does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    assert type(df) == pd.core.frame.DataFrame, "track must be a pandas dataframe."

Using type() instead of isinstance() for a typecheck.

    assert type(df['X']) == pd.core.series.Series, "track must contain X column."

Using type() instead of isinstance() for a typecheck.

    assert type(df['Y']) == pd.core.series.Series, "track must contain Y column."

Using type() instead of isinstance() for a typecheck.

    assert df.shape[0] > 0, "track must not be empty."

    l1, l2, v1, v2 = gyration_tensor(df)

The name l1 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name l2 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name v1 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name v2 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The variable v2 seems to be unused.

The variable l1 seems to be unused.

The variable l2 seems to be unused.

    projection = df['X']*v1[0] + df['Y']*v1[1]

    kurt = np.mean((projection - np.mean(projection))**4/(np.std(projection)**4))

    return kurt


def asymmetry(track):

This code seems to be duplicated in your project.

    """
    Calculates the asymmetry of the trajectory.

    Parameters
    ----------
    track : pandas DataFrame
        At a minimum, must contain an X and Y column.  The function
        msd_calc can be used to generate the correctly formatted pd dataframe.

    Returns
    -------
    l1 : numpy.float64
        Dominant eigenvalue of the gyration tensor.
    l2 : numpy.float64
        Secondary eigenvalue of the gyration tensor.
    a1 : numpy.float64
        asymmetry of the input track.  Equal to 0 for circularly symmetric tracks,
        and 1 for linear tracks.
    a2 : numpy.float64
        alternate definition of asymmetry.  Equal to 1 for circularly
        symmetric tracks, and 0 for linear tracks.
    a3 : numpy.float64
        alternate definition of asymmetry.

    Examples
    --------
    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
             'X': np.linspace(1, frames, frames)+5,
             'Y': np.linspace(1, frames, frames)+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> asymmetry(df)
    (16.5, 0.0, 1.0, 0.0, 0.69314718055994529)

    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
               'X': np.sin(np.linspace(1, frames, frames)+3),
               'Y': np.cos(np.linspace(1, frames, frames)+3)}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> asymmetry(df)
    (0.53232560128104522,
    0.42766829138901619,
    0.046430119259539708,
    0.80339606128247354,
    0.0059602683290953052)
    """

    assert type(track) == pd.core.frame.DataFrame, "track must be a pandas dataframe."

Using type() instead of isinstance() for a typecheck.

    assert type(track['X']) == pd.core.series.Series, "track must contain X column."

Using type() instead of isinstance() for a typecheck.

    assert type(track['Y']) == pd.core.series.Series, "track must contain Y column."

Using type() instead of isinstance() for a typecheck.

    assert track.shape[0] > 0, "track must not be empty."

    l1, l2, v1, v2 = gyration_tensor(track)

The name l1 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name l2 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name v1 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name v2 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The variable v2 seems to be unused.

The variable v1 seems to be unused.

    a1 = (l1**2 - l2**2)**2/(l1**2 + l2**2)**2

The name a1 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    a2 = l2/l1

The name a2 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    a3 = -np.log(1-((l1-l2)**2)/(2*(l1+l2)**2))

The name a3 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    return l1, l2, a1, a2, a3


def minBoundingRect(df):

This code seems to be duplicated in your project.

The name minBoundingRect does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name df does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

This function exceeds the maximum number of variables (26/15).

    """
    Calculates the minimum bounding rectangle of an input trajectory.

    Parameters
    ----------
    df : pandas DataFrame
        At a minimum, must contain an X and Y column.  The function
        msd_calc can be used to generate the correctly formatted pd dataframe.

    Returns
    -------
    rot_angle : numpy.float64
        Angle of rotation of the bounding box.
    area : numpy.float64
        Area of the bounding box.
    width : numpy.float64
        Width of the bounding box.
    height : numpy.float64
        Height of the bounding box.
    center_point : 2 x 1 numpy.ndarray of numpy.float64 objects
        Center point of the bounding box.
    corner_points : 4 x 2 numpy.ndarray of numpy.float64 objects
        Corner points of the bounding box.

    Examples
    --------
    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
             'X': np.linspace(1, frames, frames)+5,
             'Y': np.linspace(1, frames, frames)+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> minBoundingRect(df)
    (-2.3561944901923448,
    2.8261664256307952e-14,
    12.727922061357855,
    2.2204460492503131e-15,
    array([ 10.5,   8.5]),
    array([[  6.,   4.],
           [ 15.,  13.],
           [ 15.,  13.],
           [  6.,   4.]]))

    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
               'X': np.sin(np.linspace(1, frames, frames))+3,
               'Y': np.cos(np.linspace(1, frames, frames))+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> minBoundingRect(df)
    (0.78318530717958657,
    3.6189901131223992,
    1.9949899732081091,
    1.8140392491811692,
    array([ 3.02076903,  2.97913884]),
    array([[ 4.3676025 ,  3.04013439],
           [ 2.95381341,  1.63258851],
           [ 1.67393557,  2.9181433 ],
           [ 3.08772466,  4.32568917]]))

    Notes
    -----
    Based off of code from the following repo:
    https://github.com/dbworth/minimum-area-bounding-rectangle/blob/master/python/min_bounding_rect.py
    """

    assert type(df) == pd.core.frame.DataFrame, "track must be a pandas dataframe."

Using type() instead of isinstance() for a typecheck.

    assert type(df['X']) == pd.core.series.Series, "track must contain X column."

Using type() instead of isinstance() for a typecheck.

    assert type(df['Y']) == pd.core.series.Series, "track must contain Y column."

Using type() instead of isinstance() for a typecheck.

    assert df.shape[0] > 0, "track must not be empty."

    df2 = np.zeros((df.shape[0]+1, 2))
    df2[:-1, :] = df[['X', 'Y']].values
    df2[-1, :] = df[['X', 'Y']].values[0, :]
    hull_points_2d = df2

    edges = np.zeros((len(hull_points_2d)-1, 2))

    for i in range(len(edges)):

Consider using enumerate instead of iterating with range and len

        edge_x = hull_points_2d[i+1, 0] - hull_points_2d[i, 0]
        edge_y = hull_points_2d[i+1, 1] - hull_points_2d[i, 1]
        edges[i] = [edge_x, edge_y]

    edge_angles = np.zeros((len(edges)))

    for i in range(len(edge_angles)):

Consider using enumerate instead of iterating with range and len

        edge_angles[i] = math.atan2(edges[i, 1], edges[i, 0])
    edge_angles = np.unique(edge_angles)

    start_area = platform_c_maxint = 2 ** (struct.Struct('i').size * 8 - 1) - 1

The variable platform_c_maxint seems to be unused.

    min_bbox = (0, start_area, 0, 0, 0, 0, 0, 0)
    for i in range(len(edge_angles)):

Consider using enumerate instead of iterating with range and len

        R = np.array([[math.cos(edge_angles[i]), math.cos(edge_angles[i]-(math.pi/2))],

The name R does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                     [math.cos(edge_angles[i]+(math.pi/2)), math.cos(edge_angles[i])]])

Wrong continued indentation (add 1 space).

        rot_points = np.dot(R, np.transpose(hull_points_2d))

        min_x = np.nanmin(rot_points[0], axis=0)
        max_x = np.nanmax(rot_points[0], axis=0)
        min_y = np.nanmin(rot_points[1], axis=0)
        max_y = np.nanmax(rot_points[1], axis=0)

        width = max_x - min_x
        height = max_y - min_y
        area = width*height

        if (area < min_bbox[1]):

There is an unnecessary parenthesis after if.

            min_bbox = (edge_angles[i], area, width, height, min_x, max_x, min_y, max_y)

    angle = min_bbox[0]
    R = np.array([[math.cos(angle), math.cos(angle-(math.pi/2))], [math.cos(angle+(math.pi/2)), math.cos(angle)]])

This line is too long as per the coding-style (114/100).

The name R does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    proj_points = np.dot(R, np.transpose(hull_points_2d))

The variable proj_points seems to be unused.

    min_x = min_bbox[4]
    max_x = min_bbox[5]
    min_y = min_bbox[6]
    max_y = min_bbox[7]

    center_x = (min_x + max_x)/2
    center_y = (min_y + max_y)/2
    center_point = np.dot([center_x, center_y], R)

    corner_points = np.zeros((4, 2))
    corner_points[0] = np.dot([max_x, min_y], R)
    corner_points[1] = np.dot([min_x, min_y], R)
    corner_points[2] = np.dot([min_x, max_y], R)
    corner_points[3] = np.dot([max_x, max_y], R)

    return (angle, min_bbox[1], min_bbox[2], min_bbox[3], center_point, corner_points)


def aspectratio(track):

This code seems to be duplicated in your project.

    """
    Calculates the aspect ratio of the rectangle containing the input track.

    Parameters
    ----------
    track : pandas DataFrame
        At a minimum, must contain an X and Y column.  The function
        msd_calc can be used to generate the correctly formatted pd dataframe.

    Returns
    -------
    ar : numpy.float64
        aspect ratio of the trajectory.  Always >= 1.
    elong : numpy.float64
        elongation of the trajectory.  A transformation of the aspect ratio given
        by 1 - ar**-1.

    Examples
    --------
    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
             'X': np.linspace(1, frames, frames)+5,
             'Y': np.linspace(1, frames, frames)+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> aspectratio(df)
    (5732146505273195.0, 0.99999999999999978)

    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
               'X': np.sin(np.linspace(1, frames, frames))+3,
               'Y': np.cos(np.linspace(1, frames, frames))+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> aspectratio(df)
    (1.0997501702946164, 0.090702573174318291)

    """

    assert type(track) == pd.core.frame.DataFrame, "track must be a pandas dataframe."

Using type() instead of isinstance() for a typecheck.

    assert type(track['X']) == pd.core.series.Series, "track must contain X column."

Using type() instead of isinstance() for a typecheck.

    assert type(track['Y']) == pd.core.series.Series, "track must contain Y column."

Using type() instead of isinstance() for a typecheck.

    assert track.shape[0] > 0, "track must not be empty."

    rot_angle, area, width, height, center_point, corner_points = minBoundingRect(track)

The variable rot_angle seems to be unused.

The variable corner_points seems to be unused.

The variable area seems to be unused.

    ar = width/height

The name ar does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    if ar > 1:
        counter = 1

The variable counter seems to be unused.

    else:
        ar = 1/ar

The name ar does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    elong = 1 - (1/ar)

    return ar, elong, center_point


def boundedness(track, framerate=1):

This code seems to be duplicated in your project.

    """
    Calculates the boundedness, fractal dimension, and trappedness of the input track.

    Parameters
    ----------
    track : pandas DataFrame
        At a minimum, must contain a Frames and a MSDs column.  The function
        msd_calc can be used to generate the correctly formatted pd dataframe.
    framerate : framrate of the video being analyzed.  Actually cancels out. So
        why did I include this. Default is 1.

    Returns
    -------
    B : numpy.float64
        Boundedness of the input track.  Quantifies how much a particle with
        diffusion coefficient D is restricted by a circular confinement of radius
        r when it diffuses for a time duration N*delt.  Defined as B = D*N*delt/r**2.
        For this case, D is the short time diffusion coefficient (after 2 frames),
        and r is half the maximum distance between any two positions.
    Df : numpy.float64
        The fractal path dimension defined as Df = log(N)/log(N*d*l**-1) where L
        is the total length (sum over all steplengths), N is the number of steps,
        and d is the largest distance between any two positions.
    pf : numpy.float64
        The probability that a particle with diffusion coefficient D and traced
        for a period of time N*delt is trapped in region r0.  Given by
        pt = 1 - exp(0.2048 - 0.25117*(D*N*delt/r0**2))
        For this case, D is the short time diffusion coefficient, and r0 is half
        the maximum distance between any two positions.

    Examples
    --------
    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
             'X': np.linspace(1, frames, frames)+5,
             'Y': np.linspace(1, frames, frames)+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> boundedness(df)
    (1.0, 1.0000000000000002, 0.045311337970735499)

    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
               'X': np.sin(np.linspace(1, frames, frames)+3),
               'Y': np.cos(np.linspace(1, frames, frames)+3)}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> boundedness(df)
    (0.96037058689895005, 2.9989749477908401, 0.03576118370932313)
    """

    assert type(track) == pd.core.frame.DataFrame, "track must be a pandas dataframe."

Using type() instead of isinstance() for a typecheck.

    assert type(track['MSDs']) == pd.core.series.Series, "track must contain MSDs column."

Using type() instead of isinstance() for a typecheck.

    assert type(track['Frame']) == pd.core.series.Series, "track must contain Frame column."

Using type() instead of isinstance() for a typecheck.

    assert track.shape[0] > 0, "track must not be empty."

    df = track

The name df does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    if df.shape[0] > 2:
        length = df.shape[0]
        distance = np.zeros((length, length))

        for frame in range(0, length-1):
            distance[frame, 0:length-frame-1] = (np.sqrt(msd.nth_diff(df['X'], frame+1)**2 + msd.nth_diff(df['Y'], frame+1)**2).values)

This line is too long as per the coding-style (135/100).

        L = np.sum((np.sqrt(msd.nth_diff(df['X'], 1)**2 + msd.nth_diff(df['Y'], 1)**2).values))

The name L does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        r = np.max(distance)/2

The name r does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        N = df['Frame'][df['Frame'].shape[0]-1]

The name N does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        f = N*framerate

The name f does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        D = df['MSDs'][2]/(4*f)

The name D does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        B = D*f/(r**2)

The name B does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        Df = np.log(N)/np.log(N*2*r/L)

The name Df does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        pf = 1 - np.exp(0.2048 - 0.25117*(D*f/(r**2)))

The name pf does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    else:
        B = np.nan

The name B does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        Df = np.nan

The name Df does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        pf = np.nan

The name pf does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    return B, Df, pf


def efficiency(track):

This code seems to be duplicated in your project.

    """
    Calculates the efficiency and straitness of the input track

    Parameters
    ----------
    track : pandas DataFrame
        At a minimum, must contain a Frames and a MSDs column.  The function
        msd_calc can be used to generate the correctly formatted pd dataframe.

    Returns
    -------
    eff : numpy.float64
        Efficiency of the input track.  Relates the sum of squared step
        lengths.  Based on Helmuth et al. (2007) and defined as:
        E = |x(N-1)-x(0)|**2/SUM(|x(i) - x(i-1)|**2
    strait : numpy.float64
        Relates the net displacement L to teh sum of step lengths and is
        defined as:
        S = |x(N-1)-x(0)|/SUM(|x(i) - x(i-1)|

    Examples
    --------
    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
                   'X': np.linspace(1, frames, frames)+5,
                   'Y': np.linspace(1, frames, frames)+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> ft.efficiency(df)
    (9.0, 0.9999999999999999)

    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
                   'X': np.sin(np.linspace(1, frames, frames))+3,
                   'Y': np.cos(np.linspace(1, frames, frames))+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> ft.efficiency(df)
    (0.46192924086141945, 0.22655125514290225)
    """

    df = track

The name df does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    length = df.shape[0]
    num = (msd.nth_diff(df['X'], length-1)**2 + msd.nth_diff(df['Y'], length-1)**2)[0]
    num2 = np.sqrt(num)

    den = np.sum(msd.nth_diff(df['X'], 1)**2 + msd.nth_diff(df['Y'], 1)**2)
    den2 = np.sum(np.sqrt(msd.nth_diff(df['X'], 1)**2 + msd.nth_diff(df['Y'], 1)**2))

    eff = num/den
    strait = num2/den2
    return eff, strait


def msd_ratio(track, n1=3, n2=100):

This code seems to be duplicated in your project.

The name n1 does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name n2 does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """
    Calculates the MSD ratio of the input track at the specified frames.

    Parameters
    ----------
    track : pandas DataFrame
        At a minimum, must contain a Frames and a MSDs column.  The function
        msd_calc can be used to generate the correctly formatted pd dataframe.
    n1 : int
        First frame at which to calculate the MSD ratio.
    n2 : int
        Last frame at which to calculate the MSD ratio.

    Returns
    -------
    ratio: numpy.float64
        MSD ratio as defined by
        [MSD(n1)/MSD(n2)] - [n1/n2]
        where n1 < n2.  For Brownian motion, it is 0; for restricted motion it
        is < 0.  For directed motion it is > 0.

    Examples
    --------
    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
             'X': np.linspace(1, frames, frames)+5,
             'Y': np.linspace(1, frames, frames)+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> ft.msd_ratio(df, 1, 9)
    -0.18765432098765433

    >>> frames = 10
    >>> d = {'Frame': np.linspace(1, frames, frames),
             'X': np.sin(np.linspace(1, frames, frames))+3,
             'Y': np.cos(np.linspace(1, frames, frames))+3}
    >>> df = pd.DataFrame(data=d)
    >>> df['MSDs'], df['Gauss'] = msd_calc(df)
    >>> ft.msd_ratio(df, 1, 9)
    0.04053708075268797
    """

    df = track

The name df does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    assert n1 < n2, "n1 must be less than n2"
    ratio = (df['MSDs'][n1]/df['MSDs'][n2]) - (df['Frame'][n1]/df['Frame'][n2])
    return ratio


def calculate_features(df, framerate=1):

This code seems to be duplicated in your project.

The name df does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """
    Calculates multiple features from input MSD dataset and stores in pandas dataframe.

    Parameters
    ----------
    df : pandas dataframe
        Output from msd.all_msds2.  Must have at a minimum the following columns:
        Track_ID, Frame, X, Y, and MSDs.
    framerate : int or float64
        Framerate of the input videos from which trajectories were calculated.  Required
        for accurate calculation of some features.  Default is 1.  Possibly not required.
        Ignore if performing all calcuations without units.

    Returns
    -------
    di: pandas dataframe
        Contains a row for each trajectory in df.  Holds the following features of each
        trajetory: Track_ID, alpha, D_fit, kurtosis, asymmetry1, asymmetry2, asymmetry3,
        aspect ratio (AR), elongation, boundedness, fractal dimension (fractal_dim),
        trappedness, efficiency, straightness, MSD ratio, frames, X, and Y.

    Examples
    --------
    See example outputs from individual feature functions.
    """
    # Skeleton of Trajectory features metadata table.
    # Builds entry for each unique Track ID.
    holder = df.Track_ID.unique().astype(float)
    die = {'Track_ID': holder,
           'alpha': holder,
           'D_fit': holder,
           'kurtosis': holder,
           'asymmetry1': holder,
           'asymmetry2': holder,
           'asymmetry3': holder,
           'AR': holder,
           'elongation': holder,
           'boundedness': holder,
           'fractal_dim': holder,
           'trappedness': holder,
           'efficiency': holder,
           'straightness': holder,
           'MSD_ratio': holder,
           'frames': holder,
           'X': holder,
           'Y': holder}

    di = pd.DataFrame(data=die)

The name di does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    trackids = df.Track_ID.unique()
    partcount = trackids.shape[0]

    for particle in range(0, partcount):
        single_track_masked = df.loc[df['Track_ID'] == trackids[particle]].sort_values(['Track_ID', 'Frame'],

This line is too long as per the coding-style (109/100).

                                     ascending=[1, 1]).reset_index(drop=True)

Wrong continued indentation (add 50 spaces).

        single_track = unmask_track(single_track_masked)
        di['alpha'][particle], di['D_fit'][particle] = alpha_calc(single_track)
        di['kurtosis'][particle] = kurtosis(single_track)
        l1, l2, di['asymmetry1'][particle], di['asymmetry2'][particle], di['asymmetry3'][particle] = asymmetry(single_track)

This line is too long as per the coding-style (124/100).

The name l1 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name l2 does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The variable l1 seems to be unused.

The variable l2 seems to be unused.

        di['AR'][particle], di['elongation'][particle], (di['X'][particle], di['Y'][particle]) = aspectratio(single_track)

This line is too long as per the coding-style (122/100).

        di['boundedness'][particle], di['fractal_dim'][particle], di['trappedness'][particle] = boundedness(single_track, framerate)

This line is too long as per the coding-style (132/100).

        di['efficiency'][particle], di['straightness'][particle] = efficiency(single_track)
        di['frames'][particle] = single_track.shape[0]
        if single_track['Frame'][single_track.shape[0]-2] > 2:
            di['MSD_ratio'][particle] = msd_ratio(single_track, 2, single_track['Frame'][single_track.shape[0]-2])

This line is too long as per the coding-style (114/100).

        else:
            di['MSD_ratio'][particle] = 0

    return di