featuremapper/command.py
def compute_orientation_from_direction(current_values):
    """
    Return the orientation corresponding to the given direction.

    Wraps the value to be in the range [0,pi), and rounds it slightly
    so that wrapped values are precisely the same (to avoid biases
    caused by vector averaging with keep_peak=True).

    Note that in very rare cases (1 in 10^-13?), rounding could lead
    to different values for a wrapped quantity, and thus give a
    heavily biased orientation map.  In that case, just choose a
    different number of directions to test, to avoid that floating
    point boundary.
    """
    return np.round(((dict(current_values)['direction']) + (np.pi / 2)) % np.pi,
                    13)

    Return the orientation corresponding to the given direction.

    Wraps the value to be in the range [0,pi), and rounds it slightly
    so that wrapped values are precisely the same (to avoid biases
    caused by vector averaging with keep_peak=True).

    Note that in very rare cases (1 in 10^-13?), rounding could lead
    to different values for a wrapped quantity, and thus give a
    heavily biased orientation map.  In that case, just choose a
    different number of directions to test, to avoid that floating
    point boundary.
    
Return the orientation corresponding to the given direction.
Wraps the value to be in the range [0,pi), and rounds it slightly
so that wrapped values are precisely the same (to avoid biases
caused by vector averaging with keep_peak=True).

Note that in very rare cases (1 in 10^-13?), rounding could lead
to different values for a wrapped quantity, and thus give a
heavily biased orientation map.  In that case, just choose a
different number of directions to test, to avoid that floating
point boundary.
Return the orientation corresponding to the given direction . Wraps the value to be in the range [ 0 pi ) and rounds it slightly so that wrapped values are precisely the same ( to avoid biases caused by vector averaging with keep_peak = True ) . Note that in very rare cases ( 1 in 10^ - 13? ) rounding could lead to different values for a wrapped quantity and thus give a heavily biased orientation map . In that case just choose a different number of directions to test to avoid that floating point boundary .
def compute_orientation_from_direction(current_values):
    return np.round(((dict(current_values)['direction']) + (np.pi / 2)) % np.pi,
                    13)
def compute_orientation_from_direction ( current_values ) : return np . round ( ( ( dict ( current_values ) [ 'direction' ] ) + ( np . pi / 2 ) ) % np . pi , 13 )
Return the orientation corresponding to the given direction.
Return the orientation corresponding to the given direction .
"""
    Return the orientation corresponding to the given direction.

    Wraps the value to be in the range [0,pi), and rounds it slightly
    so that wrapped values are precisely the same (to avoid biases
    caused by vector averaging with keep_peak=True).

    Note that in very rare cases (1 in 10^-13?), rounding could lead
    to different values for a wrapped quantity, and thus give a
    heavily biased orientation map.  In that case, just choose a
    different number of directions to test, to avoid that floating
    point boundary.
    """
current_values