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

  • Elly

    Elly

    3 EKİM 2005
  • SRT Photoshop Tutorials

    SRT Photosho

    19 Aralık 2012
  • TrenchTech Computer Repair Tutorials

    TrenchTech C

    19 EYLÜL 2014