Esta página se ha traducido mediante traducción automática. Haga clic aquí para ver la última versión en inglés.

maldad

Rotación media del cuaternión

Sintaxis

quatAverage = meanrot(quat)

quatAverage = meanrot(quat,dim)

quatAverage = meanrot(___,nanflag)

Descripción

quatAverage = meanrot(quat) devuelve la rotación promedio de los elementos de quat a lo largo de la primera dimensión de la matriz cuyo tamaño no es igual a 1.

• Si quat es un vector, meanrot(quat) devuelve la rotación promedio de los elementos.

• Si quat es una matriz, meanrot(quat) devuelve un vector fila que contiene la rotación promedio de cada columna.

• Si quat es una matriz multidimensional, entonces mearot(quat) opera a lo largo de la primera dimensión de la matriz cuyo tamaño no sea igual a 1, tratando los elementos como vectores. Esta dimensión pasa a ser 1 mientras que los tamaños de todas las demás dimensiones siguen siendo los mismos.

La función meanrot normaliza los cuaterniones de entrada, quat, antes de calcular la media.

quatAverage = meanrot(quat,dim) devuelve la rotación promedio a lo largo de la dimensión dim. Por ejemplo, si quat es una matriz, entonces meanrot(quat,2) es un vector columna que contiene la media de cada fila.

quatAverage = meanrot(___,nanflag) especifica si se deben incluir u omitir los valores NaN del cálculo para cualquiera de las sintaxis anteriores. meanrot(quat,"includenan") incluye todos los valores NaN en el cálculo, mientras que mean(quat,"omitnan") los ignora.

Ejemplos

Rotación media del cuaternión

Crea una matriz de cuaterniones correspondientes a tres conjuntos de ángulos de Euler.

eulerAngles = [40 20 10; ...
               50 10 5; ...
               45 70 1];

quat = quaternion(eulerAngles,"eulerd","ZYX","frame");

Determine la rotación promedio representada por los cuaterniones. Convierta la rotación promedio a ángulos de Euler en grados para facilitar la lectura.

quatAverage = meanrot(quat)

quatAverage = quaternion
      0.88863 - 0.062598i +  0.27822j +  0.35918k

eulerAverage = eulerd(quatAverage,"ZYX","frame")

eulerAverage = 1×3

   45.7876   32.6452    6.0407

Ruido rotacional promedio

Utilice meanrot sobre una secuencia de cuaterniones para promediar el ruido aditivo.

Cree un vector de 1e6 cuaterniones cuya distancia, tal como se define en la función dist, desde el cuaternión(1,0,0,0) se distribuya normalmente. Trazar los ángulos de Euler correspondientes al vector cuaternión ruidoso.

nrows = 1e6;
ax = 2*rand(nrows,3) - 1;   
ax = ax./sqrt(sum(ax.^2,2));
ang = 0.5*randn(size(ax,1),1);
q = quaternion(ax.*ang ,"rotvec");

noisyEulerAngles = eulerd(q,"ZYX","frame");

figure(1)

subplot(3,1,1)
plot(noisyEulerAngles(:,1))
title("Z-Axis")
ylabel("Rotation (degrees)")
hold on

subplot(3,1,2)
plot(noisyEulerAngles(:,2))
title("Y-Axis")
ylabel("Rotation (degrees)")
hold on

subplot(3,1,3)
plot(noisyEulerAngles(:,3))
title("X-Axis")
ylabel("Rotation (degrees)")
hold on

Utilice meanrot para determinar el cuaternión promedio dado el vector de cuaterniones. Convierta a ángulos de Euler y trace los resultados.

qAverage = meanrot(q);

qAverageInEulerAngles = eulerd(qAverage,"ZYX","frame");

figure(1)

subplot(3,1,1)
plot(ones(nrows,1)*qAverageInEulerAngles(:,1))
title("Z-Axis")

subplot(3,1,2)
plot(ones(nrows,1)*qAverageInEulerAngles(:,2))
title("Y-Axis")

subplot(3,1,3)
plot(ones(nrows,1)*qAverageInEulerAngles(:,3))
title("X-Axis")

El algoritmo meanrot y sus limitaciones

El algoritmo meanrot

La función meanrot genera un cuaternión que minimiza la norma de Frobenius al cuadrado de la diferencia entre matrices de rotación. Considere dos cuaterniones:

• q0 representa que no hay rotación.

• q90 representa una rotación de 90 grados alrededor del eje x.

q0 = quaternion([0 0 0],"eulerd","ZYX","frame");
q90 = quaternion([0 0 90],"eulerd","ZYX","frame");

Crea un barrido de cuaternión, qSweep, que representa rotaciones de 0 a 180 grados alrededor del eje x.

eulerSweep = (0:1:180)';
qSweep = quaternion([zeros(numel(eulerSweep),2),eulerSweep], ...
    "eulerd","ZYX","frame");

Convierte q0, q90 y qSweep en matrices de rotación. En un bucle, calcule la métrica a minimizar para cada miembro del barrido del cuaternión. Trazar los resultados y devolver el valor del barrido de Euler que corresponde al mínimo de la métrica.

r0     = rotmat(q0,"frame");
r90    = rotmat(q90,"frame");
rSweep = rotmat(qSweep,"frame");

metricToMinimize = zeros(size(rSweep,3),1);
for i = 1:numel(qSweep)
    metricToMinimize(i) = norm((rSweep(:,:,i) - r0),"fro").^2 + ...
                          norm((rSweep(:,:,i) - r90),"fro").^2;
end

plot(eulerSweep,metricToMinimize)
xlabel("Euler Sweep (degrees)")
ylabel("Metric to Minimize")

[~,eulerIndex] = min(metricToMinimize);
eulerSweep(eulerIndex)

ans = 
45

El mínimo de la métrica corresponde al barrido del ángulo de Euler a 45 grados. Es decir, meanrot define el promedio entre quaterion([0 0 0],"ZYX","frame") y quaternion([0 0 90],"ZYX","frame") como quaternion([0 0 45],"ZYX","frame"). Llame a meanrot con q0 y q90 para verificar el mismo resultado.

eulerd(meanrot([q0,q90]),"ZYX","frame")

ans = 1×3

         0         0   45.0000

Limitaciones

La métrica que utiliza meanrot para determinar la rotación media no es única para cuaterniones significativamente separados. Repita el experimento anterior para cuaterniones que estén separados por 180 grados.

q180 = quaternion([0 0 180],"eulerd","ZYX","frame");
r180 = rotmat(q180,"frame");

for i = 1:numel(qSweep)
    metricToMinimize(i) = norm((rSweep(:,:,i) - r0),"fro").^2 + ...
                          norm((rSweep(:,:,i) - r180),"fro").^2;
end

plot(eulerSweep,metricToMinimize)
xlabel("Euler Sweep (degrees)")
ylabel("Metric to Minimize")

[~,eulerIndex] = min(metricToMinimize);
eulerSweep(eulerIndex)

ans = 
49

Las medias de los cuaterniones generalmente se calculan para rotaciones cercanas entre sí, lo que hace que el caso extremo que se muestra en este ejemplo sea poco probable en aplicaciones del mundo real. Para promediar dos cuaterniones que están significativamente separados, utilice la función slerp. Repita el experimento usando slerp y verifique que la media del cuaternión devuelta sea más intuitiva para distancias grandes.

qMean = slerp(q0,q180,0.5);
q0_q180 = eulerd(qMean,"ZYX","frame")

q0_q180 = 1×3

         0         0   90.0000

Argumentos de entrada

quat — Cuaternión

objeto quaternion | arreglo de objetos quaternion

Cuaternión para el cual se calculará la media, especificado como un objeto quaternion o una matriz de objetos quaternion de cualquier dimensionalidad.

dim — Dimensión para operar a lo largo

escalar entero positivo

Dimensión sobre la que operar, especificada como un escalar entero positivo. Si no se especifica ningún valor, el valor predeterminado es la primera dimensión del arreglo cuyo tamaño no es igual a 1.

La dimensión dim indica la dimensión cuya longitud se reduce a 1. El size(quatAverage,dim) es 1, mientras que los tamaños de todas las demás dimensiones siguen siendo los mismos.

Tipos de datos: double | single

nanflag — condición NaN

"includenan" (predeterminado) | "omitnan"

Condición NaN, especificada como uno de estos valores:

• "includenan" –– Incluye valores NaN al calcular la rotación media, lo que da como resultado NaN.

• "omitnan" –– Ignorar todos los valores NaN en la entrada.

Tipos de datos: char | string

Argumentos de salida

quatAverage — Rotación promedio del cuaternión

objeto quaternion | arreglo de objetos quaternion

Rotación promedio de cuaternión, devuelta como un objeto quaternion o una matriz de objetos quaternion.

Algoritmos

meanrot determina una media de cuaternión, $$\overline{q}$$, según [1]. $$\overline{q}$$ es el cuaternión que minimiza la norma de Frobenius al cuadrado de la diferencia entre matrices de rotación:

$$\overline{q}=\arg \begin{array}{c}\min \\ q\in {\text{S}}^3\end{array}{\displaystyle \sum _{i=1}^n{\Vert A\left(q\right)-A\left(q_i\right)\Vert }_F^2}$$

Referencias

[1] Markley, F. Landis, Yang Chen, John Lucas Crassidis, and Yaakov Oshman. "Average Quaternions." Journal of Guidance, Control, and Dynamics. Vol. 30, Issue 4, 2007, pp. 1193-1197.

Capacidades ampliadas

Generación de código C/C++
Genere código C y C++ mediante MATLAB® Coder™.

Historial de versiones

Introducido en R2019b

Consulte también

Funciones

• dist | slerp

Objetos

• quaternion

Temas

• Rotaciones, orientación y cuaterniones