LCOV - app.info - gfx/qcms/matrix.c

LCOV - code coverage report
| Current view: | directory - gfx/qcms - matrix.c (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 56 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 6 | 0 | 0.0 %

           1                 : /* vim: set ts=8 sw=8 noexpandtab: */
           2                 : //  qcms
           3                 : //  Copyright (C) 2009 Mozilla Foundation
           4                 : //  Copyright (C) 1998-2007 Marti Maria
           5                 : //
           6                 : // Permission is hereby granted, free of charge, to any person obtaining
           7                 : // a copy of this software and associated documentation files (the "Software"),
           8                 : // to deal in the Software without restriction, including without limitation
           9                 : // the rights to use, copy, modify, merge, publish, distribute, sublicense,
          10                 : // and/or sell copies of the Software, and to permit persons to whom the Software
          11                 : // is furnished to do so, subject to the following conditions:
          12                 : //
          13                 : // The above copyright notice and this permission notice shall be included in
          14                 : // all copies or substantial portions of the Software.
          15                 : //
          16                 : // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
          17                 : // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
          18                 : // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
          19                 : // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
          20                 : // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
          21                 : // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
          22                 : // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
          23                 :
          24                 : #include <stdlib.h>
          25                 : #include "qcmsint.h"
          26                 : #include "matrix.h"
          27                 :
          28               0 : struct vector matrix_eval(struct matrix mat, struct vector v)
          29                 : {
          30                 :         struct vector result;
          31               0 :         result.v[0] = mat.m[0][0]*v.v[0] + mat.m[0][1]*v.v[1] + mat.m[0][2]*v.v[2];
          32               0 :         result.v[1] = mat.m[1][0]*v.v[0] + mat.m[1][1]*v.v[1] + mat.m[1][2]*v.v[2];
          33               0 :         result.v[2] = mat.m[2][0]*v.v[0] + mat.m[2][1]*v.v[1] + mat.m[2][2]*v.v[2];
          34               0 :         return result;
          35                 : }
          36                 :
          37                 : //XXX: should probably pass by reference and we could
          38                 : //probably reuse this computation in matrix_invert
          39               0 : float matrix_det(struct matrix mat)
          40                 : {
          41                 :         float det;
          42               0 :         det = mat.m[0][0]*mat.m[1][1]*mat.m[2][2] +
          43               0 :                 mat.m[0][1]*mat.m[1][2]*mat.m[2][0] +
          44               0 :                 mat.m[0][2]*mat.m[1][0]*mat.m[2][1] -
          45               0 :                 mat.m[0][0]*mat.m[1][2]*mat.m[2][1] -
          46               0 :                 mat.m[0][1]*mat.m[1][0]*mat.m[2][2] -
          47               0 :                 mat.m[0][2]*mat.m[1][1]*mat.m[2][0];
          48               0 :         return det;
          49                 : }
          50                 :
          51                 : /* from pixman and cairo and Mathematics for Game Programmers */
          52                 : /* lcms uses gauss-jordan elimination with partial pivoting which is
          53                 :  * less efficient and not as numerically stable. See Mathematics for
          54                 :  * Game Programmers. */
          55               0 : struct matrix matrix_invert(struct matrix mat)
          56                 : {
          57                 :         struct matrix dest_mat;
          58                 :         int i,j;
          59                 :         static int a[3] = { 2, 2, 1 };
          60                 :         static int b[3] = { 1, 0, 0 };
          61                 :
          62                 :         /* inv  (A) = 1/det (A) * adj (A) */
          63               0 :         float det = matrix_det(mat);
          64                 :
          65               0 :         if (det == 0) {
          66               0 :                 dest_mat.invalid = true;
          67                 :         } else {
          68               0 :                 dest_mat.invalid = false;
          69                 :         }
          70                 :
          71               0 :         det = 1/det;
          72                 :
          73               0 :         for (j = 0; j < 3; j++) {
          74               0 :                 for (i = 0; i < 3; i++) {
          75                 :                         double p;
          76               0 :                         int ai = a[i];
          77               0 :                         int aj = a[j];
          78               0 :                         int bi = b[i];
          79               0 :                         int bj = b[j];
          80                 :
          81               0 :                         p = mat.m[ai][aj] * mat.m[bi][bj] -
          82               0 :                                 mat.m[ai][bj] * mat.m[bi][aj];
          83               0 :                         if (((i + j) & 1) != 0)
          84               0 :                                 p = -p;
          85                 :
          86               0 :                         dest_mat.m[j][i] = det * p;
          87                 :                 }
          88                 :         }
          89               0 :         return dest_mat;
          90                 : }
          91                 :
          92               0 : struct matrix matrix_identity(void)
          93                 : {
          94                 :         struct matrix i;
          95               0 :         i.m[0][0] = 1;
          96               0 :         i.m[0][1] = 0;
          97               0 :         i.m[0][2] = 0;
          98               0 :         i.m[1][0] = 0;
          99               0 :         i.m[1][1] = 1;
         100               0 :         i.m[1][2] = 0;
         101               0 :         i.m[2][0] = 0;
         102               0 :         i.m[2][1] = 0;
         103               0 :         i.m[2][2] = 1;
         104               0 :         i.invalid = false;
         105               0 :         return i;
         106                 : }
         107                 :
         108               0 : struct matrix matrix_invalid(void)
         109                 : {
         110               0 :         struct matrix inv = matrix_identity();
         111               0 :         inv.invalid = true;
         112               0 :         return inv;
         113                 : }
         114                 :
         115                 :
         116                 : /* from pixman */
         117                 : /* MAT3per... */
         118               0 : struct matrix matrix_multiply(struct matrix a, struct matrix b)
         119                 : {
         120                 :         struct matrix result;
         121                 :         int dx, dy;
         122                 :         int o;
         123               0 :         for (dy = 0; dy < 3; dy++) {
         124               0 :                 for (dx = 0; dx < 3; dx++) {
         125               0 :                         double v = 0;
         126               0 :                         for (o = 0; o < 3; o++) {
         127               0 :                                 v += a.m[dy][o] * b.m[o][dx];
         128                 :                         }
         129               0 :                         result.m[dy][dx] = v;
         130                 :                 }
         131                 :         }
         132               0 :         result.invalid = a.invalid || b.invalid;
         133               0 :         return result;
         134                 : }
         135                 :
         136                 :

Generated by: LCOV version 1.7