Разложение матрицы

Используйте следующую схему при разборе RealityKit matrix4x4:

┌                   ┐
|   a   b   c   d   |
|   e   f   g   h   |
|   i   j   k   l   |
|   0   0   0   1   |
└                   ┘

Этот метод позволяет разложить матрицу ModelEntity или AnchorEntity и получить отдельно векторы масштаба, ориентации и положения.

import UIKit
import RealityKit

extension ViewController {
    
    func decomposingMatrixOf(_ entity: Entity) -> (scale: SIMD3<Float>,
                                             orientation: simd_quatf,
                                                position: SIMD3<Float>) {
        // SCALE EXTRACTION 
        // only positive scale is considered in this example
        let a = entity.transform.matrix.columns.0.x
        let e = entity.transform.matrix.columns.0.y
        let i = entity.transform.matrix.columns.0.z
        let b = entity.transform.matrix.columns.1.x
        let f = entity.transform.matrix.columns.1.y
        let j = entity.transform.matrix.columns.1.z
        let c = entity.transform.matrix.columns.2.x
        let g = entity.transform.matrix.columns.2.y
        let k = entity.transform.matrix.columns.2.z
        let xScale = sqrt((a * a) + (e * e) + (i * i))
        let yScale = sqrt((b * b) + (f * f) + (j * j))
        let zScale = sqrt((c * c) + (g * g) + (k * k))
        let scale = SIMD3<Float>(xScale, yScale, zScale)
        
        // ORIENTATION EXTRACTION
        let orientation = entity.transform.rotation
        
        // POSITION EXTRACTION
        let d = entity.transform.matrix.columns.3.x
        let h = entity.transform.matrix.columns.3.y
        let l = entity.transform.matrix.columns.3.z
        let position = SIMD3<Float>(d, h, l)
        
        return (scale, orientation, position)
    }
}

class ViewController: UIViewController {
    
    @IBOutlet var arView: ARView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        var matrixS = simd_float4x4()
        matrixS.columns.0.x = 2.0
        matrixS.columns.1.y = 2.5
        matrixS.columns.2.z = 1.5

        let model = ModelEntity(mesh: .generateBox(size: 0.25))

        let rotationTransform = Transform(pitch: 0, yaw: .pi/6, roll: 0)
        print(rotationTransform.rotation)                        // 0

        // your formula is just a part of transform
        let matrixR = Transform(scale: .one,
                             rotation: simd_quatf(rotationTransform.matrix),
                          translation: .zero).matrix
                
        let matrixSR = simd_mul(matrixR, matrixS)
        model.transform.matrix = matrixSR
        model.position.z = -0.5
        
        let anchor = AnchorEntity()
        anchor.addChild(model)
        arView.scene.anchors.append(anchor)
        
        // Decomposing
        print( self.decomposingMatrixOf(model).scale )           // 1
        print( model.scale )                                     // 2
        print( self.decomposingMatrixOf(model).orientation )     // 3
        print( model.transform.rotation )                        // 4
        print( self.decomposingMatrixOf(model).position )        // 5
        print( model.position )                                  // 6
    }
}

Результаты в консоли:

(real и imaginary части построенного кватерниона здесь согласованы)

simd_quatf(real: 0.9659258, imag: SIMD3<Float>(0.0, 0.258819, 0.0))     // 0
SIMD3<Float>(2.0, 2.5, 1.5)                                             // 1
SIMD3<Float>(2.0, 2.5, 1.5)                                             // 2
simd_quatf(real: 0.9659258, imag: SIMD3<Float>(0.0, 0.258819, 0.0))     // 3
simd_quatf(real: 0.9659258, imag: SIMD3<Float>(0.0, 0.258819, 0.0))     // 4
SIMD3<Float>(0.0, 0.0, -0.5)                                            // 5
SIMD3<Float>(0.0, 0.0, -0.5)                                            // 6

Вращение представляет собой комбинацию масштабирования и сдвига.

Simd_quatf.init(_ rotationMatrix: simd_float4x4) учитывает только ориентацию объекта и не учитывает его реальный масштаб и положение. Таким образом, чтобы матрица преобразования была полной, необходимы значения всех 16 ячеек.

Матрица RealityKit 4x4, как и любая другая simd-матрица 4x4 , не содержит ЧИСТЫХ значений поворота. Вращение — это продукт сдвига и масштаба. Поэтому, извлекая из матрицы, например, значения Y-поворота, вы получите данные, расположенные в 4 ячейках матрицы.

Причем результат вращения вычисляется с помощью четырех тригонометрических функций. Извлечение значений вращения с помощью .init(real:imag:) дает вам следующий результат. Все расчеты поворотов в RealityKit, ARKit и SceneKit выполняются в радианах.

let transform = Transform(scale: SIMD3<Float>(1, 2, 3),
                       rotation: simd_quatf(angle: .pi/6, axis: [0, 1, 0]),
                    translation: SIMD3<Float>(10, 20, 30))

Результирующая матрица:

┌                              ┐
|  0.86   0.00   1.49   10.00  |
|  0.00   2.00   0.00   20.00  |
| -0.49   0.00   2.59   30.00  |
|  0.00   0.00   0.00    1.00  |
└                              ┘

Если вы напечатаете transform.rotation, вы получите следующий результат:

simd_quatf(real: 0.9659258, imag: SIMD3<Float>(0.0, 0.258819, 0.0))

Когда вы печатаете эти подсвойства, вы получите начальные значения:

print(transform.rotation.angle)
print(transform.rotation.axis)

0.52359873                      //  Float.pi/6
SIMD3<Float>(0.0, 1.0, 0.0)     //  Y axis

Дополнение к вышесказанному

Вот что говорится в официальной документации Apple о var matrix: float4x4 {get set}

Компонент Transform не может представлять все преобразования, которые может представлять обычная матрица 4x4. Таким образом, использование матрицы 4x4 для задания преобразования является событием с потерями, которое может привести к отбрасыванию определенных преобразований, таких как сдвиг.

Вот почему ваши результаты значений rotation-only противоречивы. Кроме того, simd_quatf.init(_ rotationMatrix: simd_float4x4) игнорирует последнюю строку и последний столбец матрицы 4x4 (т. е. мы передаем матрицу 3x3 ), поэтому мы теряем переключатель Однородные координаты и значения перевода.

Формула, которую вы пытаетесь вывести, всегда будет содержать противоречивый результат. В RealityKit 2.0 нет возможности, используя только инициализатор simd_quatf, сгенерировать матрицу преобразования 4x4.

Расширение

Это добавляет свойства Transform к simd_float4x4.

extension simd_float4x4 {
    var translation: simd_float3 {
        return [columns.3.x, columns.3.y, columns.3.z]
    }

    var rotation: simd_quatf {
        // This would work only when scale is 1:
        // return simd_quatf(self)

        return Transform(matrix: self).rotation
    }

    var scale: simd_float3 {
        return [
            simd_length(simd_float3(columns.0.x, columns.0.y, columns.0.z)),
            simd_length(simd_float3(columns.1.x, columns.1.y, columns.1.z)),
            simd_length(simd_float3(columns.2.x, columns.2.y, columns.2.z)),
        ]
    }
}

Затем вы можете использовать его непосредственно из значения матрицы:

let matrix = simd_float4x4( ... )

print( matrix.translation )
print( matrix.rotation )
print( matrix.scale )