numpy.arctan2() em Python

Exemplo de NumPy Arctan2

importar numpy como ppool y=[1,1] x=[1,1.732] print(ppool.arctan2(y,x)) [0.78539816 0.52361148] 

Ângulo em graus = ângulo em radianos * 180/pi

Numpy Arctan() Exemplo #2

import numpy as ppool degree=0 y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x) print(b) for vals in b: degree= vals*(180/3.14) print(degree) 

Saída:

[-0.46364761 1.04718485] -26.578525356734104 60.02970472117416 

import numpy as ppool y=[-1,1.732] x=[2,1] b=ppool.arctan2(y,x)*(180/3.14) print (b) 

Saída:

[-26.57852536 60.02970472] 

NumPy Arctan2 Exemplo #3

def doa(self, receiver, source): ``` Calcula a direção de chegada wrt uma fonte e um receptor ``` s_ind = self.key2ind(source) r_ind = self.key2ind(receiver) # vetor do receptor para a fonte v = self.X[:,s_ind] - self.X[: ,r_ind] azimute = np.arctan2(v[1], v[0]) elevação = np.arctan2(v[2], la.norm(v[ :2])) azimute = azimute + 2*np.pi se azimute < 0. else azimute elevação = elevação + 2*np.pi se elevação < 0. else elevação return np.array([azimute, elevação]) 

NumPy Arctan2 Exemplo #4

def mtx_freq2visi(M, p_mic_x, p_mic_y): """ construa a matriz que mapeia a série de Fourier para a visibilidade:param M: a expansão da série de Fourier é limitado de -M a M:param p_mic_x: um vetor que contém microfones x coordenadas:param p_mic_y: um vetor que contém microfones y coordenadas:retorno: """ num_mic = p_mic_x.size ms = np.reshape(np.arange(- M , M + 1, step=1), (1, -1), order=`F`) G = np.zeros((num_mic * (num_mic - 1), 2 * M + 1), dtype=complex, order =`C`) count_G = 0 for q in range(num_mic): p_x_outer = p_mic_x[q] p_y_outer = p_mic_y[q] for qp in range(num_mic): se não q == qp: p_x_qqp = p_x_outer - p_mic_x[qp ] p_y_qqp = p_y_outer - p_mic_y[qp] norm_p_qqp = np. sqrt(p_x_qqp ** 2 + p_y_qqp ** 2) phi_qqp = np.arctan2(p_y_qqp, p_x_qqp) G[count_G,:] = ( -1j) ** ms * sp.special.jv(ms, norm_p_qqp) * np.exp(1j * ms * phi_qqp) count_G += 1 return G 

NumPy Arctan2 Exemplo #5

def vector_angle(u, v, direction=None): ``` vector_angle(u, v) fornece o ângulo entre os dois vetores u e v. O argumento opcional direction é por padrão None, que especifica que o menor possível ângulo entre os vetores deve ser relatado; se os vetores u e v são vetores 2D e os parâmetros de direção True e False especificam as direções no sentido horário ou anti-horário, respectivamente; se os vetores são vetores 3D, então a direção pode ser um ponto 3D que não está no plano que contém u, v e a origem, e especifica em torno de qual direção (uxv ou vxu) o ângulo anti-horário de u a v deve ser relatado (o vetor de produto vetorial que tem um produto escalar positivo com o argumento de direção é usado como eixo de rotação). ``` se a direção for Nenhum: retornar np.arccos(vector_angle_cos(u, v)) elif direção for Verdadeiro: retornar np.arctan2(v[1], v[0]) - np. arctan2(u[1], u[0]) elif direction is False: return np.arctan2(u[1], u[0]) - np.arctan2(v[1], v [0]) else: axis1 = normalize(u) axis2 = normalize(np.cross(u, v)) if np.dot(axis2, direction) < 0: axis2 = -axis2 return np.arctan2(np.dot(axis2, v), np.dot(axis1, v)) 

NumPy Arctan2 Example #6

def __init__(self, line): data = line.split(` `) data[1:] = [float(x) for x in data[1:]] self.classname = data[0] self.xmin = data[1] self.ymin = data[2 ] self.xmax = data[1]+data[3] self.ymax = data[2]+data[4] self.box2d = np.array([self.xmin,self.ymin,self.xmax,self. ymax]) self.centroid = np.array([data[5],data[6],data[7]]) self.unused_dimension = np.array([data[8],data[9],data[10] ]]) self.w = data[8] self.l = data[9] self.h = data[10] self.orientation = np.zeros((3,)) self.orientation[0] = data[11 ] auto.orientação[1] = data[12] self.heading_angle = -1 * np.arctan2(self.orientation[1], self.orientation[0]) 

np.arctan2 Exemplo #7

def stanleyControl(state, cx, cy, cyaw, last_target_idx): """:param state: (State object):param cx: ([float]):param cy: ([float]): param cyaw: ([float]):param last_target_idx: (int):return: (float, int, float) """ # Cross track error current_target_idx, error_front_axle = calcTargetIndex(state, cx, cy) if last_target_idx >= current_target_idx: current_target_idx = last_target_idx # theta_e corrige o erro de título theta_e = normalizeAngle(cyaw[current_target_idx] - state.yaw) # theta_d corrige o erro de cross track theta_d = np.arctan2(K_STANLEY_CONTROL * error_front_axle, state.v) # Controle de direção delta = theta_e + theta_d return delta, current_target_idx, error_front_axle 

np arctan2 Exemplo #8

def calcTargetIndex(state, cx, cy): """:param state: (objeto de estado):param cx: [float]:param cy: [float]:return: (int, float) """ # Calcula a posição do eixo dianteiro fx = state.x + CAR_LENGTH * np.cos(state.yaw) fy = state.y + CAR_LENGTH * np.sin(state.yaw) # Procura o índice do ponto mais próximo dx = [fx - icx para icx em cx] dy = [fy - gelado para gelado em cy] d = [np. sqrt(idx ** 2 + idy ** 2) para (idx, idy) em zip(dx, dy)] error_front_axle = min(d) target_idx = d.index(error_front_axle) target_yaw = normalizeAngle(np.arctan2(fy - cy[target_idx], fx - cx[target_idx]) - state.yaw ) if target_yaw > 0.0: error_front_axle = - error_front_axle return target_idx, error_front_axle 

NumPy Arctan2 Example #9

def vehicle_flat_reverse(zflag, params={}): # Obtém os valores dos parâmetros b = params.get(`wheelbase`, 3.) # Cria um vetor para armazenar o estado e as entradas x = np.zeros(3) u = np.zeros(2) # Dadas as variáveis planas, resolva para o estado x[ 0] = zflag[0][0] # x posição x[1] = zflag[1][0] # y posição x[2] = np.arctan2(zflag[1][1 ], zflag[0][1]) # tan(theta) = ydot/xdot # E em seguida resolva para as entradas u[0] = zflag[0][1] * np.cos(x[2]) + zflag[1][1] * np.sin(x[2]) thdot_v = zflag[1][2 ] * np.cos(x[2]) - zflag[0][2] * np.sin(x[2]) u[1] = np.arctan2(thdot_v, u[0 ]**2 / b) return x, u # Função para calcular o RHS da dinâmica do sistema 

np.arctan2 Exemplo #10

def GetNeighborCells(self, p, nr, dp = Nenhum): ``` Retorna todas as células não mais do que uma determinada distância em qualquer direção de uma célula especificada p: A célula da qual obter os vizinhos nr: Raio do vizinho dp: Preferência de direção ``` pi, pj, pk = p tqm = self.qm * self.qp nc = [(pi - i * tqm, pj - j * tqm, pk) para i no intervalo(-nr, nr + 1) para j no intervalo(-nr, nr + 1)] se dp não for Nenhum: #Ordenar pontos com base na preferência de direção dpa = np.arctan2(dp[1], dp[0]) #Obter ângulo de direção preferido #Preferir direções em a direção de dp; classificar com base na magnitude do ângulo da última direção nc = sorted(nc, key = lambda t: np.abs(np.arctan2(t[1], t[0]) - dpa)) return nc #Obtém a posição 3d atual do player 

Python atan ou atan2, o que devo usar?

Pergunta do StackOverflow

Minha fórmula f=arctan(ImZ/ReZ)

Existem duas opções :

Opção 1 (atan):

ImZ=-4.593172163003 ImR=-4.297336384845 >>> z=y/x >>> f1=math.atan(z) >>> f1 0.8186613519278327 

Opção 2 (atan2)

>>> f=math.atan2(y,x) >>> f -2.3229313016619604 

Por que esses dois resultados são diferentes?

Resposta: h3>

Atan recebe um único argumento e Atan2 recebe dois argumentos. O objetivo de usar dois argumentos em vez de um é coletar informações sobre os sinais das entradas para retornar o quadrante apropriado do ângulo calculado, o que não é possível para o argumento único Atan

O resultado de Atan2 está sempre entre -pi e pi.

Referência: https://en.wikipedia.org/wiki/Atan2

Versão arquivada

numpy.arctan2 (arr1, arr2, elenco = & # 39; mesmo_tipo & # 39 ;, ordem = & # 39; K & # 39 ;, dtype = Nenhum, ufunc & # 39; arctan & # 39;):
Calcula o arco-tangente elementar de arr1 / arr2 escolhendo o quadrante correto.¬†O quadrante é escolhido de modo que arctan2 (x1, x2) é o sinal de ângulo em radianos entre um raio que termina na origem e passa pelo ponto (1, 0) e um raio que termina na origem e passa pelo ponto (x2) x1).

Parâmetros:

arr1: [array_like] valor real;  coordenadas y
arr2: [array_like] valor real;¬†coordenadas x.¬†Deve corresponder à forma das coordenadas y.
out: [ndarray, array_like [ OPCIONAL ]] array da mesma forma que x .
onde: [array_like, opcional] True value significa calcular as funções universais (ufunc) naquela posição, False value significa deixar o valor na saída sozinho.

Nota:
2pi Radianos = 360 graus
A convenção é retornar o ângulo z cuja parte real está em [-pi / 2 , pi / 2].

Retorno: Elemento-a-arco tangente de arr1 / arr2.¬†Os valores ‚Äã‚Äãestão no intervalo fechado [-pi / 2, pi / 2].

Código # 1: Trabalho

coordenadas x: [-1, 1, 1 , -1] coordenadas y: [-1, -1, 1, 1] arctan2 valores: [-135 . -45. 45. 135.] 

a: [0. 3.14159265 0.78539816] b: [1.57079633 -1.57079633]