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

Desde R2019b

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 del arreglo 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 un arreglo multidimensional, entonces mearot(quat) opera a lo largo de la primera dimensión del arreglo cuyo tamaño no es 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 incluyen u omiten los valores NaN del cálculo para cualquiera de las sintaxis anteriores. meanrot(quat,"includenan") incluye todos los valores de 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 cuaterniones 1e6 cuya distancia, según lo definido por la función dist , desde el cuaternión(1,0,0,0) esté distribuida 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 y limitaciones de meanrot

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 sin 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");

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

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

Convierta 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 alejados, use 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

quaternion objeto | arreglo de objetos quaternion

Cuaternión para el cual calcular la media, especificado como un objeto quaternion o un arreglo 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 — NaN condición

"includenan" (predeterminado) | "omitnan"

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

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

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

Tipos de datos: char | string

Argumentos de salida

quatAverage — Rotación promedio del cuaternión

quaternion objeto | arreglo de objetos quaternion

Rotación promedio del cuaternión, devuelta como un objeto quaternion o un arreglo de objetos quaternion .

Algoritmos

meanrot determina la media del 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