diff_classifier.features.minboundrect()

Complexity

Conditions

5

Size

Total Lines	139
Code Lines	54

Duplication

Lines	139
Ratio	100 %

Importance

Changes

0

"""Functions to calculate trajectory features from input trajectory data
def minboundrect(track):

This code seems to be duplicated in your project.

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

    Parameters
    ----------
    dframe : pandas.core.frame.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 : numpy.ndarray
        Center point of the bounding box.
    corner_pts : numpy.ndarray
        Corner points of the bounding box.

    Examples
    --------
    >>> frames = 10
    >>> data1 = {'Frame': np.linspace(1, frames, frames),
    ...          'X': np.linspace(1, frames, frames)+5,
    ...          'Y': np.linspace(1, frames, frames)+3}
    >>> dframe = pd.DataFrame(data=data1)
    >>> dframe['MSDs'], dframe['Gauss'] = msd_calc(dframe)
    >>> minboundrect(dframe)
    (-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
    >>> data1 = {'Frame': np.linspace(1, frames, frames),
    ...          'X': np.sin(np.linspace(1, frames, frames))+3,
    ...          'Y': np.cos(np.linspace(1, frames, frames))+3}
    >>> dframe = pd.DataFrame(data=data1)
    >>> dframe['MSDs'], dframe['Gauss'] = msd_calc(dframe)
    >>> minboundrect(dframe)
    (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

    """

    dframe = track
    assert isinstance(dframe, pd.core.frame.DataFrame), "track must be a pandas\
     dataframe."
    assert isinstance(dframe['X'], pd.core.series.Series), "track must contain\
     X column."
    assert isinstance(dframe['Y'], pd.core.series.Series), "track must contain\
     Y column."
    assert dframe.shape[0] > 0, "track must not be empty."

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

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

    for i in range(len(edges)):

The variable range does not seem to be defined.

        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)):
        edge_angles[i] = math.atan2(edges[i, 1], edges[i, 0])
    edge_angles = np.unique(edge_angles)

    start_area = 2 ** (struct.Struct('i').size * 8 - 1) - 1
    min_bbox = (0, start_area, 0, 0, 0, 0, 0, 0)
    for i in range(len(edge_angles)):
        rads = np.array([[math.cos(edge_angles[i]),
                          math.cos(edge_angles[i]-(math.pi/2))],
                        [math.cos(edge_angles[i]+(math.pi/2)),

Wrong continued indentation (add 1 space).

                         math.cos(edge_angles[i])]])

        rot_points = np.dot(rads, 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]:
            min_bbox = (edge_angles[i], area, width, height,
                        min_x, max_x, min_y, max_y)

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

    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], rads)

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

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