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

  • Google Chrome

    Google Chrom

    1 EYLÜL 2008
  • SamsTech

    SamsTech

    4 NİSAN 2014
  • sk8ingis4me

    sk8ingis4me

    16 Mart 2006