misc/tools/brightspot.c

   1 #include <stdio.h>
   2 #include <math.h>
   3
   4 // USAGE: see brightspot.sh (and in the future brightspot.bat)
   5 // It should output the right parameters for the sun direction in q3map2's format.
   6 // But probably is broken.
   7
   8 #define false 0
   9 #define true 1
  10
  11 int flip[6*3] =
  12 {
  13         false, false,  true, // "rt"
  14          true,  true,  true, // "lf"
  15         false,  true, false, // "bk"
  16          true, false, false, // "ft"
  17         false, false,  true, // "up"
  18         false, false,  true  // "dn"
  19 };
  20
  21 static const double skyboxtexcoord2f[6*4*2] =
  22 {
  23     // skyside[0]
  24     0, 1,
  25     1, 1,
  26     1, 0,
  27     0, 0,
  28     // skyside[1]
  29     1, 0,
  30     0, 0,
  31     0, 1,
  32     1, 1,
  33     // skyside[2]
  34     1, 1,
  35     1, 0,
  36     0, 0,
  37     0, 1,
  38     // skyside[3]
  39     0, 0,
  40     0, 1,
  41     1, 1,
  42     1, 0,
  43     // skyside[4]
  44     0, 1,
  45     1, 1,
  46     1, 0,
  47     0, 0,
  48     // skyside[5]
  49     0, 1,
  50     1, 1,
  51     1, 0,
  52     0, 0
  53 };
  54
  55
  56 static const double skyboxvertex3f[6*4*3] =
  57 {
  58         // skyside[0]
  59          16, -16,  16,
  60          16, -16, -16,
  61          16,  16, -16,
  62          16,  16,  16,
  63         // skyside[1]
  64         -16,  16,  16,
  65         -16,  16, -16,
  66         -16, -16, -16,
  67         -16, -16,  16,
  68         // skyside[2]
  69          16,  16,  16,
  70          16,  16, -16,
  71         -16,  16, -16,
  72         -16,  16,  16,
  73         // skyside[3]
  74         -16, -16,  16,
  75         -16, -16, -16,
  76          16, -16, -16,
  77          16, -16,  16,
  78         // skyside[4]
  79         -16, -16,  16,
  80          16, -16,  16,
  81          16,  16,  16,
  82         -16,  16,  16,
  83         // skyside[5]
  84          16, -16, -16,
  85         -16, -16, -16,
  86         -16,  16, -16,
  87          16,  16, -16
  88 };
  89
  90 void Unmap2f(double x, double y, const double *corners, double *u, double *v)
  91 {
  92         // x - corners[0] == *u * (corners[2] - corners[0]) + *v * (corners[4] - corners[2]);
  93         // y - corners[1] == *u * (corners[3] - corners[1]) + *v * (corners[5] - corners[3]);
  94
  95         double xc0 = x - corners[0];
  96         double yc1 = y - corners[1];
  97         double c20 = corners[2] - corners[0];
  98         double c31 = corners[3] - corners[1];
  99         double c42 = corners[4] - corners[2];
 100         double c53 = corners[5] - corners[3];
 101
 102         // xc0 == *u * c20 + *v * c42;
 103         // yc1 == *u * c31 + *v * c53;
 104
 105         double det = c20 * c53 - c31 * c42;
 106         double du = xc0 * c53 - yc1 * c42;
 107         double dv = c20 * yc1 - c31 * xc0;
 108
 109         *u = du / det;
 110         *v = dv / det;
 111 }
 112
 113 void Map3f(double u, double v, const double *corners, double *x, double *y, double *z)
 114 {
 115         *x = corners[0] + u * (corners[3] - corners[0]) + v * (corners[6] - corners[3]);
 116         *y = corners[1] + u * (corners[4] - corners[1]) + v * (corners[7] - corners[4]);
 117         *z = corners[2] + u * (corners[5] - corners[2]) + v * (corners[8] - corners[5]);
 118 }
 119
 120 void MapCoord(int pic, int y, int x, double vec[3])
 121 {
 122         int h;
 123         int flipx = flip[3*pic+0];
 124         int flipy = flip[3*pic+1];
 125         int flipdiag = flip[3*pic+2];
 126         double u, v;
 127
 128         if(flipx)
 129                 x = 511 - x;
 130
 131         if(flipy)
 132                 y = 511 - y;
 133
 134         if(flipdiag)
 135         {
 136                 h = x; x = y; y = h;
 137         }
 138
 139         Unmap2f((x + 0.5) / 512.0, (y + 0.5) / 512.0, skyboxtexcoord2f + 4*2*pic, &u, &v);
 140         Map3f(u, v, skyboxvertex3f + 6*2*pic, &vec[0], &vec[1], &vec[2]);
 141 }
 142
 143 int main(int argc, char **argv)
 144 {
 145         FILE *f;
 146         int i, j, k;
 147         unsigned char picture[6][512][512];
 148         unsigned char max;
 149         double brightvec[3];
 150         double pitch, yaw, l;
 151
 152         if(argc != 2)
 153         {
 154                 fprintf(stderr, "Usage: %s imagefile.gray\n", *argv);
 155                 return 1;
 156         }
 157
 158         f = fopen(argv[1], "rb");
 159         if(!f)
 160         {
 161                 perror("fopen");
 162                 return 1;
 163         }
 164         fread(&picture, sizeof(picture), 1, f);
 165         fclose(f);
 166
 167         brightvec[0] = brightvec[1] = brightvec[2] = 0;
 168         max = 0;
 169         for(i = 0; i < 6; ++i)
 170                 for(j = 0; j < 512; ++j)
 171                         for(k = 0; k < 512; ++k)
 172                                 if(picture[i][j][k] > max)
 173                                         max = picture[i][j][k];
 174         for(i = 0; i < 6; ++i)
 175                 for(j = 0; j < 512; ++j)
 176                         for(k = 0; k < 512; ++k)
 177                         {
 178                                 double vec[3], f;
 179                                 MapCoord(i, j, k, vec);
 180                                 f = pow(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2], -1.5); // I know what I am doing.
 181                                 f *= exp(10 * (picture[i][j][k] - max));
 182                                 brightvec[0] += f * vec[0];
 183                                 brightvec[1] += f * vec[1];
 184                                 brightvec[2] += f * vec[2];
 185                         }
 186
 187         l = sqrt(brightvec[0]*brightvec[0] + brightvec[1]*brightvec[1] + brightvec[2]*brightvec[2]);
 188         fprintf(stderr, "vec = %f %f %f\n", brightvec[0] / l, brightvec[1] / l, brightvec[2] / l);
 189
 190         pitch = atan2(brightvec[2], sqrt(brightvec[0]*brightvec[0] + brightvec[1]*brightvec[1]));
 191         yaw = atan2(brightvec[1], brightvec[0]);
 192
 193         printf("%f %f\n", yaw * 180 / M_PI, pitch * 180 / M_PI);
 194         return 0;
 195 }