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

  • Amena

    Amena

    15 Kasım 2006
  • MandMEvangelists

    MandMEvangel

    28 Ocak 2008
  • Soulkiller13 ツ

    Soulkiller13

    30 Mayıs 2013