diff_classifier.features.minBoundingRect()

Complexity

Conditions

9

Size

Total Lines	130
Code Lines	49

Duplication

Lines	130
Ratio	100 %

Importance

Changes

0

import numpy as np
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)