SORU
18 Temmuz 2009, CUMARTESİ


eviren 4x4 bir matris

4x4 bir matris ters çevirmek için nasıl örnek kod bir uygulama arıyorum. eleminiation, LU ayrıştırma, vb Gauss olduğunu biliyorum. ama detaylı bir şekilde bakmak yerine gerçekten sadece kod için bunu yapmak için arıyorum.

C 16 dizi mevcuttur dil ideal cloumn-büyük düzen içinde yüzer.

teşekkür ederim!

CEVAP
18 Temmuz 2009, CUMARTESİ


burada:

bool gluInvertMatrix(const double m[16], double invOut[16])
{
    double inv[16], det;
    int i;

    inv[0] = m[5]  * m[10] * m[15] - 
             m[5]  * m[11] * m[14] - 
             m[9]  * m[6]  * m[15]   
             m[9]  * m[7]  * m[14]  
             m[13] * m[6]  * m[11] - 
             m[13] * m[7]  * m[10];

    inv[4] = -m[4]  * m[10] * m[15]   
              m[4]  * m[11] * m[14]   
              m[8]  * m[6]  * m[15] - 
              m[8]  * m[7]  * m[14] - 
              m[12] * m[6]  * m[11]   
              m[12] * m[7]  * m[10];

    inv[8] = m[4]  * m[9] * m[15] - 
             m[4]  * m[11] * m[13] - 
             m[8]  * m[5] * m[15]   
             m[8]  * m[7] * m[13]   
             m[12] * m[5] * m[11] - 
             m[12] * m[7] * m[9];

    inv[12] = -m[4]  * m[9] * m[14]   
               m[4]  * m[10] * m[13]  
               m[8]  * m[5] * m[14] - 
               m[8]  * m[6] * m[13] - 
               m[12] * m[5] * m[10]   
               m[12] * m[6] * m[9];

    inv[1] = -m[1]  * m[10] * m[15]   
              m[1]  * m[11] * m[14]   
              m[9]  * m[2] * m[15] - 
              m[9]  * m[3] * m[14] - 
              m[13] * m[2] * m[11]   
              m[13] * m[3] * m[10];

    inv[5] = m[0]  * m[10] * m[15] - 
             m[0]  * m[11] * m[14] - 
             m[8]  * m[2] * m[15]   
             m[8]  * m[3] * m[14]   
             m[12] * m[2] * m[11] - 
             m[12] * m[3] * m[10];

    inv[9] = -m[0]  * m[9] * m[15]   
              m[0]  * m[11] * m[13]   
              m[8]  * m[1] * m[15] - 
              m[8]  * m[3] * m[13] - 
              m[12] * m[1] * m[11]   
              m[12] * m[3] * m[9];

    inv[13] = m[0]  * m[9] * m[14] - 
              m[0]  * m[10] * m[13] - 
              m[8]  * m[1] * m[14]   
              m[8]  * m[2] * m[13]   
              m[12] * m[1] * m[10] - 
              m[12] * m[2] * m[9];

    inv[2] = m[1]  * m[6] * m[15] - 
             m[1]  * m[7] * m[14] - 
             m[5]  * m[2] * m[15]   
             m[5]  * m[3] * m[14]   
             m[13] * m[2] * m[7] - 
             m[13] * m[3] * m[6];

    inv[6] = -m[0]  * m[6] * m[15]   
              m[0]  * m[7] * m[14]   
              m[4]  * m[2] * m[15] - 
              m[4]  * m[3] * m[14] - 
              m[12] * m[2] * m[7]   
              m[12] * m[3] * m[6];

    inv[10] = m[0]  * m[5] * m[15] - 
              m[0]  * m[7] * m[13] - 
              m[4]  * m[1] * m[15]   
              m[4]  * m[3] * m[13]   
              m[12] * m[1] * m[7] - 
              m[12] * m[3] * m[5];

    inv[14] = -m[0]  * m[5] * m[14]   
               m[0]  * m[6] * m[13]   
               m[4]  * m[1] * m[14] - 
               m[4]  * m[2] * m[13] - 
               m[12] * m[1] * m[6]   
               m[12] * m[2] * m[5];

    inv[3] = -m[1] * m[6] * m[11]   
              m[1] * m[7] * m[10]   
              m[5] * m[2] * m[11] - 
              m[5] * m[3] * m[10] - 
              m[9] * m[2] * m[7]   
              m[9] * m[3] * m[6];

    inv[7] = m[0] * m[6] * m[11] - 
             m[0] * m[7] * m[10] - 
             m[4] * m[2] * m[11]   
             m[4] * m[3] * m[10]   
             m[8] * m[2] * m[7] - 
             m[8] * m[3] * m[6];

    inv[11] = -m[0] * m[5] * m[11]   
               m[0] * m[7] * m[9]   
               m[4] * m[1] * m[11] - 
               m[4] * m[3] * m[9] - 
               m[8] * m[1] * m[7]   
               m[8] * m[3] * m[5];

    inv[15] = m[0] * m[5] * m[10] - 
              m[0] * m[6] * m[9] - 
              m[4] * m[1] * m[10]   
              m[4] * m[2] * m[9]   
              m[8] * m[1] * m[6] - 
              m[8] * m[2] * m[5];

    det = m[0] * inv[0]   m[1] * inv[4]   m[2] * inv[8]   m[3] * inv[12];

    if (det == 0)
        return false;

    det = 1.0 / det;

    for (i = 0; i < 16; i  )
        invOut[i] = inv[i] * det;

    return true;
}

Bu GLU kütüphane MESA uygulamadan kaldırıldı.

Bunu Paylaş:
  • Google+
  • E-Posta
Etiketler:

YORUMLAR

SPONSOR VİDEO

Rastgele Yazarlar

  • Ben Schoon

    Ben Schoon

    23 Kasım 2012
  • itfigueres

    itfigueres

    12 EKİM 2013
  • Jeb Corliss

    Jeb Corliss

    17 Kasım 2006