d3/tfile.h

   1 // Copyright 2002, 2003, 2005 David Hilvert <dhilvert@auricle.dyndns.org>,
   2 //                                          <dhilvert@ugcs.caltech.edu>
   3
   4 /*  This file is part of the Anti-Lamenessing Engine.
   5
   6     The Anti-Lamenessing Engine is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 3 of the License, or
   9     (at your option) any later version.
  10
  11     The Anti-Lamenessing Engine is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with the Anti-Lamenessing Engine; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 /*
  22  * d3/tfile.h: Read and write 3D transformation data files.
  23  */
  24
  25 /*
  26  * This version of ALE reads and writes version 0 3D transformation data files.
  27  */
  28
  29 #ifndef __d3tfile_h__
  30 #define __d3tfile_h__
  31
  32 #include "pt.h"
  33
  34 #define D3_TFILE_VERSION     0
  35 #define D3_TFILE_VERSION_MAX 0
  36
  37 extern int tfile_input_version;
  38 extern int tfile_output_version;
  39
  40 /*
  41  * Structure to describe a transformation data file to load data from.
  42  */
  43
  44 struct tload_t {
  45         const char *filename;
  46         FILE *file;
  47 };
  48
  49 /*
  50  * Structure to describe a transformation data file to write data to.
  51  */
  52
  53 struct tsave_t {
  54         const char *filename;
  55         const char *target;
  56         const char *orig;
  57         FILE *file;
  58 };
  59
  60 /*
  61  * Create a new tload_t transformation data file structure, used for
  62  * reading data from transformation data files.
  63  */
  64
  65 static inline struct tload_t *tload_new(const char *filename) {
  66         FILE *file = fopen (filename, "r");
  67         struct tload_t *result = NULL;
  68
  69         if (!file) {
  70                 fprintf(stderr, "tload: Error: could not open transformation data file '%s'.", filename);
  71                 exit(1);
  72         }
  73
  74         result = (struct tload_t *)
  75                 malloc(sizeof(struct tload_t));
  76         result->filename = filename;
  77         result->file = file;
  78
  79         return result;
  80 }
  81
  82 /*
  83  * Load the first transformation from a transformation data file associated with
  84  * transformation data file structure T, or return the default transformation
  85  * if no transformation is available.
  86  *
  87  *      T is a pointer to the tload_t transformation data file structure.
  88  *
  89  *      DEFAULT_TRANSFORM is the default transformation result.
  90  *
  91  *      IS_DEFAULT is used to signal a non-default transformation result.
  92  */
  93
  94 static inline pt tload_first(struct tload_t *t,
  95                 pt default_transform, int *is_default) {
  96
  97         pt result = default_transform;
  98
  99         *is_default = 1;
 100
 101         /*
 102          * If there is no file, return the default.
 103          */
 104
 105         if (t == NULL)
 106                 return result;
 107
 108         /*
 109          * Search through the initial part of the file to determine
 110          * its version.
 111          */
 112
 113         /*
 114          * Skip comments
 115          */
 116
 117         int first_character;
 118
 119         first_character = fgetc(t->file);
 120
 121         while (first_character == ' '
 122             || first_character == 0xa
 123             || first_character == 0xd
 124             || first_character == '\t'
 125             || first_character == '#') {
 126                 ungetc(first_character, t->file);
 127                 char line[1024];
 128                 fgets(line, 1024, t->file);
 129                 if (strlen(line) >= 1023) {
 130                         fprintf(stderr,
 131                                 "\n3d-trans-load: Error: line too long in input file\n");
 132                         exit(1);
 133                 }
 134
 135                 first_character = fgetc(t->file);
 136         }
 137
 138         if (first_character != EOF)
 139                 ungetc(first_character, t->file);
 140
 141         if (first_character != 'W') {
 142                 fprintf(stderr, "\n3d-trans-load: First command must be a version number.\n");
 143                 exit(1);
 144         }
 145
 146         /*
 147          * Obtain version from version command string.
 148          */
 149
 150         char line[1024];
 151         fgets(line, 1024, t->file);
 152         if (strlen(line) >= 1023) {
 153                 fprintf(stderr,
 154                         "\n3d-trans-load: Error: line too long in input file\n");
 155                 exit(1);
 156         }
 157
 158         int count = sscanf(line, "W %d", &tfile_input_version);
 159
 160         if (count < 1) {
 161                 fprintf(stderr, "Error in 3d transformation "
 162                                 "file version command.\n");
 163                 exit(1);
 164         } else if (tfile_input_version > D3_TFILE_VERSION_MAX) {
 165                 fprintf(stderr, "Unsupported 3D transformation "
 166                                 "file version %d\n",
 167                                 tfile_input_version);
 168                 exit(1);
 169         }
 170
 171         /*
 172          * Read each line of the file until we find a transformation
 173          * or EOF.
 174          */
 175
 176         while (!feof(t->file)) {
 177                 char line[1024];
 178
 179                 fgets(line, 1024, t->file);
 180
 181                 if (feof(t->file))
 182                         return result;
 183
 184                 if (strlen(line) >= 1023) {
 185                         fprintf(stderr,
 186                                 "\ntrans-load: Error: line too long in input file\n");
 187                         exit(1);
 188                 }
 189
 190                 const double rtod_multiplier = 180 / M_PI;
 191
 192                 switch (line[0]) {
 193                         case ' ':
 194                         case 0xa:
 195                         case 0xd:
 196                         case '\t':
 197                         case '#':
 198                                 /* Comment or whitespace */
 199                                 break;
 200                         case 'D':
 201                         case 'd':
 202                                 /* Default transformation */
 203                                 return result;
 204                         case 'V':
 205                         case 'v':
 206                                 unsigned int count;
 207                                 double view_angle;
 208
 209                                 count = sscanf(line, "V %lf", &view_angle);
 210
 211                                 if (count < 1) {
 212                                         fprintf(stderr, "\n3d-trans-load: Error: "
 213                                                         "Malformed 'V' command.\n");
 214                                         exit(1);
 215                                 }
 216
 217                                 result.view_angle(view_angle / rtod_multiplier);
 218
 219                                 break;
 220                         case 'E':
 221                         case 'e':
 222                                 /* Euclidean transformation data */
 223                                 *is_default = 0;
 224                                 {
 225                                         double width, height;
 226                                         double values[6] = {0, 0, -1, 0, 0, 0};
 227                                         int count;
 228
 229                                         count = sscanf(line, "E %lf%lf%lf%lf%lf%lf%lf%lf",
 230                                                         &width, &height,
 231                                                         &values[1], &values[0], &values[2],
 232                                                         &values[4], &values[3], &values[5]);
 233
 234                                         if (count < 8)
 235                                                 fprintf(stderr, "\n3d-trans-load: warning: "
 236                                                                 "Missing args for 'E'\n");
 237
 238                                         if (width != result.scaled_width()
 239                                          || height != result.scaled_height()) {
 240                                                 fprintf(stderr, "\n3d-trans-load: Error: "
 241                                                                 "Scaled image width and/or height mismatch.");
 242                                         }
 243
 244                                         for (int i = 3; i < 6; i++) {
 245                                                 values [i] /= rtod_multiplier;
 246                                         }
 247
 248                                         result.e().set(values);
 249
 250                                         return result;
 251                                 }
 252                                 break;
 253                         default:
 254                                 fprintf(stderr,
 255                                         "\ntrans-load: Error in tload_first: unrecognized command '%s'\n",
 256                                         line);
 257                                 exit(1);
 258                 }
 259         }
 260
 261         /*
 262          * EOF reached: return default transformation.
 263          */
 264
 265         return result;
 266 }
 267
 268 /*
 269  * Load the next transformation from a transformation data file associated with
 270  * transformation data file structure T, or return the default transformation
 271  * if no transformation is available.
 272  *
 273  *      T is a pointer to the tload_t transformation data file structure.
 274  *
 275  *      IS_P is nonzero if a projective transformation is expected.
 276  *
 277  *      DEFAULT_TRANSFORM is the default transformation result.
 278  *
 279  *      IS_DEFAULT is used to signal a non-default transformation result.
 280  */
 281
 282 static inline pt tload_next(struct tload_t *t,
 283                 pt default_transform, int *is_default) {
 284
 285         pt result = default_transform;
 286
 287         *is_default = 1;
 288
 289         /*
 290          * Read each line of the file until we find a transformation.
 291          */
 292
 293         while (t && !feof(t->file)) {
 294                 char line[1024];
 295
 296                 fgets(line, 1024, t->file);
 297
 298                 if (feof(t->file))
 299                         return result;
 300
 301                 if (strlen(line) >= 1023) {
 302                         fprintf(stderr,
 303                                 "\ntrans-load: warning: line too long in input file\n");
 304                 }
 305
 306                 const double rtod_multiplier = 180 / M_PI;
 307
 308                 switch (line[0]) {
 309                         case ' ':
 310                         case 0xa:
 311                         case 0xd:
 312                         case '\t':
 313                         case '#':
 314                                 /* Comment or whitespace */
 315                                 break;
 316                         case 'D':
 317                         case 'd':
 318                                 /* Default transformation */
 319                                 return result;
 320                         case 'V':
 321                         case 'v':
 322                                 unsigned int count;
 323                                 double view_angle;
 324
 325                                 count = sscanf(line, "V %lf", &view_angle);
 326
 327                                 if (count < 1) {
 328                                         fprintf(stderr, "\n3d-trans-load: Error: "
 329                                                         "Malformed 'V' command.\n");
 330                                         exit(1);
 331                                 }
 332
 333                                 result.view_angle(view_angle / rtod_multiplier);
 334
 335                                 break;
 336                         case 'E':
 337                         case 'e':
 338                                 /* Euclidean transformation data */
 339                                 *is_default = 0;
 340                                 {
 341                                         double width, height;
 342                                         double values[6] = {0, 0, -1, 0, 0, 0};
 343                                         int count;
 344
 345                                         count = sscanf(line, "E %lf%lf%lf%lf%lf%lf%lf%lf",
 346                                                         &width, &height,
 347                                                         &values[1], &values[0], &values[2],
 348                                                         &values[4], &values[3], &values[5]);
 349
 350                                         if (count < 8)
 351                                                 fprintf(stderr, "\n3d-trans-load: warning: "
 352                                                                 "Missing args for 'E'\n");
 353
 354                                         if (width != result.scaled_width()
 355                                          || height != result.scaled_height()) {
 356                                                 fprintf(stderr, "\n3d-trans-load: Error: "
 357                                                                 "Scaled image width and/or height mismatch.");
 358                                         }
 359
 360                                         for (int i = 3; i < 6; i++) {
 361                                                 values [i] /= rtod_multiplier;
 362                                         }
 363
 364                                         result.e().set(values);
 365
 366                                         return result;
 367                                 }
 368                                 break;
 369                         default:
 370                                 fprintf(stderr,
 371                                         "\ntrans-load: Error in tload_next: unrecognized command '%s'\n",
 372                                         line);
 373                                 exit(1);
 374                 }
 375         }
 376
 377         return result;
 378 }
 379
 380 /*
 381  * Create a new tsave_t transformation data file structure, used for
 382  * writing data to transformation data files.
 383  */
 384
 385 static inline struct tsave_t *tsave_new(const char *filename) {
 386         FILE *file = fopen (filename, "w");
 387         struct tsave_t *result = NULL;
 388
 389         if (!file) {
 390                 fprintf(stderr, "tsave: Error: could not open transformation data file '%s'.", filename);
 391                 exit(1);
 392         }
 393
 394         result = (struct tsave_t *)
 395                 malloc(sizeof(struct tsave_t));
 396         result->filename = filename;
 397         result->file = file;
 398         result->orig = "unknown";
 399         result->target = "unknown";
 400
 401         fprintf(file, "# created by ALE 3D transformation file handler version %d\n",
 402                         D3_TFILE_VERSION);
 403
 404         fclose(file);
 405
 406         return result;
 407 }
 408
 409 /*
 410  * Save the first transformation to a transformation data file associated with
 411  * transformation data file structure T, or do nothing if T is NULL.  This
 412  * function also establishes the output file version.
 413  *
 414  *      OFFSET is the transformation to be saved.
 415  *
 416  *      IS_PROJECTIVE indicates whether to write a projective transformation.
 417  *
 418  */
 419
 420 static inline void tsave_first(struct tsave_t *t, pt offset) {
 421
 422         if (t == NULL)
 423                 return;
 424
 425         t->file = fopen(t->filename, "a");
 426
 427         tfile_output_version = 0;
 428
 429         fprintf(t->file, "# producing 3D transformation file syntax version %d\n", tfile_output_version);
 430         fprintf(t->file, "W %d\n", tfile_output_version);
 431
 432         // fprintf(t->file, "# Comment: Target output file is %s\n", t->target);
 433         // fprintf(t->file, "# Comment: Original frame is %s\n", t->orig);
 434
 435         const double rtod_multiplier = 180 / M_PI;
 436
 437         fprintf(t->file, "V %lf\n", offset.view_angle() * rtod_multiplier);
 438
 439         fprintf(t->file, "E ");
 440         fprintf(t->file, "%f %f ", (double) offset.scaled_width(), (double) offset.scaled_height());
 441         fprintf(t->file, "%f ",    (double) offset.e().get_translation(1));
 442         fprintf(t->file, "%f ",    (double) offset.e().get_translation(0));
 443         fprintf(t->file, "%f ",    (double) offset.e().get_translation(2));
 444         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(1) * rtod_multiplier);
 445         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(0) * rtod_multiplier);
 446         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(2) * rtod_multiplier);
 447
 448         fprintf(t->file, "\n");
 449
 450         fclose(t->file);
 451 }
 452
 453 /*
 454  * Save the next transformation to a transformation data file associated with
 455  * transformation data file structure T, or do nothing if T is NULL.
 456  *
 457  *      OFFSET is the transformation to be saved.
 458  *
 459  *      IS_PROJECTIVE indicates whether to write a projective transformation.
 460  *
 461  */
 462
 463 static inline void tsave_next(struct tsave_t *t, pt offset) {
 464
 465         if (t == NULL)
 466                 return;
 467
 468         t->file = fopen(t->filename, "a");
 469
 470         const double rtod_multiplier = 180 / M_PI;
 471
 472         fprintf(t->file, "V %lf\n", offset.view_angle() * rtod_multiplier);
 473
 474         fprintf(t->file, "E ");
 475         fprintf(t->file, "%f %f ", (double) offset.scaled_width(), (double) offset.scaled_height());
 476         fprintf(t->file, "%f ",    (double) offset.e().get_translation(1));
 477         fprintf(t->file, "%f ",    (double) offset.e().get_translation(0));
 478         fprintf(t->file, "%f ",    (double) offset.e().get_translation(2));
 479         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(1) * rtod_multiplier);
 480         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(0) * rtod_multiplier);
 481         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(2) * rtod_multiplier);
 482
 483         fprintf(t->file, "\n");
 484
 485         fclose(t->file);
 486 }
 487
 488 /*
 489  * Write information to a transformation file indicating the target output
 490  * file.
 491  */
 492
 493 static inline void tsave_target(struct tsave_t *t, const char *filename) {
 494         if (t == NULL)
 495                 return;
 496
 497         t->target = filename;
 498         if (t != NULL) {
 499                 t->file = fopen(t->filename, "a");
 500
 501
 502                 fclose(t->file);
 503         }
 504 }
 505
 506 /*
 507  * Write information to a transformation data file indicating the filename
 508  * of the original frame (i.e. the first frame in the sequence of input
 509  * frames).
 510  */
 511
 512 static inline void tsave_orig(struct tsave_t *t, const char *filename) {
 513         if (t == NULL)
 514                 return;
 515
 516         t->orig = filename;
 517 }
 518
 519 /*
 520  * Write information to a transformation data file indicating the filename
 521  * of a supplemental frame (i.e. a frame in the sequence of input frames
 522  * that is not the first frame).
 523  */
 524
 525 static inline void tsave_info(struct tsave_t *t, const char *filename) {
 526         if (t != NULL) {
 527                 t->file = fopen(t->filename, "a");
 528
 529                 fprintf(t->file, "# Comment: Supplemental frame %s\n", filename);
 530
 531                 fclose(t->file);
 532         }
 533 }
 534
 535 /*
 536  * Write information to a transformation data file indicating the tonal
 537  * registration multiplier.
 538  */
 539
 540 static inline void tsave_trm(struct tsave_t *t, ale_real r, ale_real g, ale_real b) {
 541        if (t != NULL) {
 542                t->file = fopen(t->filename, "a");
 543
 544                fprintf(t->file, "# Comment: Exposure [r=%f g=%f b=%f]\n", r, g, b);
 545
 546                fclose(t->file);
 547        }
 548 }
 549
 550 /*
 551  * Write information to a transformation data file indicating the average
 552  * pixel magnitude.
 553  */
 554
 555 static inline void tsave_apm(struct tsave_t *t, ale_real r, ale_real g, ale_real b) {
 556        if (t != NULL) {
 557                t->file = fopen(t->filename, "a");
 558
 559                fprintf(t->file, "# Comment: Avg magnitude [r=%f g=%f b=%f]\n", r, g, b);
 560
 561                fclose(t->file);
 562        }
 563 }
 564
 565
 566 /*
 567  * Destroy a tload_t transformation data file structure.
 568  */
 569
 570 static inline void tload_delete(struct tload_t *victim) {
 571         if (victim)
 572                 fclose(victim->file);
 573         free(victim);
 574 }
 575
 576 /*
 577  * Destroy a tsave_t transformation data file structure.
 578  */
 579
 580 static inline void tsave_delete(struct tsave_t *victim) {
 581         free(victim);
 582 }
 583
 584 #endif