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                 char *fgets_result = fgets(line, 1024, t->file);
 129
 130                 assert(fgets_result);
 131
 132                 if (strlen(line) >= 1023) {
 133                         fprintf(stderr,
 134                                 "\n3d-trans-load: Error: line too long in input file\n");
 135                         exit(1);
 136                 }
 137
 138                 first_character = fgetc(t->file);
 139         }
 140
 141         if (first_character != EOF)
 142                 ungetc(first_character, t->file);
 143
 144         if (first_character != 'W') {
 145                 fprintf(stderr, "\n3d-trans-load: First command must be a version number.\n");
 146                 exit(1);
 147         }
 148
 149         /*
 150          * Obtain version from version command string.
 151          */
 152
 153         char line[1024];
 154         char *fgets_result = fgets(line, 1024, t->file);
 155
 156         assert(fgets_result);
 157
 158         if (strlen(line) >= 1023) {
 159                 fprintf(stderr,
 160                         "\n3d-trans-load: Error: line too long in input file\n");
 161                 exit(1);
 162         }
 163
 164         int count = sscanf(line, "W %d", &tfile_input_version);
 165
 166         if (count < 1) {
 167                 fprintf(stderr, "Error in 3d transformation "
 168                                 "file version command.\n");
 169                 exit(1);
 170         } else if (tfile_input_version > D3_TFILE_VERSION_MAX) {
 171                 fprintf(stderr, "Unsupported 3D transformation "
 172                                 "file version %d\n",
 173                                 tfile_input_version);
 174                 exit(1);
 175         }
 176
 177         /*
 178          * Read each line of the file until we find a transformation
 179          * or EOF.
 180          */
 181
 182         while (!feof(t->file)) {
 183                 char line[1024];
 184
 185                 if (!fgets(line, 1024, t->file))
 186                         return result;
 187
 188                 if (strlen(line) >= 1023) {
 189                         fprintf(stderr,
 190                                 "\ntrans-load: Error: line too long in input file\n");
 191                         exit(1);
 192                 }
 193
 194                 const double rtod_multiplier = 180 / M_PI;
 195
 196                 switch (line[0]) {
 197                         case ' ':
 198                         case 0xa:
 199                         case 0xd:
 200                         case '\t':
 201                         case '#':
 202                                 /* Comment or whitespace */
 203                                 break;
 204                         case 'D':
 205                         case 'd':
 206                                 /* Default transformation */
 207                                 return result;
 208                         case 'V':
 209                         case 'v':
 210                                 unsigned int count;
 211                                 double view_angle;
 212
 213                                 count = sscanf(line, "V %lf", &view_angle);
 214
 215                                 if (count < 1) {
 216                                         fprintf(stderr, "\n3d-trans-load: Error: "
 217                                                         "Malformed 'V' command.\n");
 218                                         exit(1);
 219                                 }
 220
 221                                 result.view_angle(view_angle / rtod_multiplier);
 222
 223                                 break;
 224                         case 'E':
 225                         case 'e':
 226                                 /* Euclidean transformation data */
 227                                 *is_default = 0;
 228                                 {
 229                                         double width, height;
 230                                         double values[6] = {0, 0, -1, 0, 0, 0};
 231                                         int count;
 232
 233                                         count = sscanf(line, "E %lf%lf%lf%lf%lf%lf%lf%lf",
 234                                                         &width, &height,
 235                                                         &values[1], &values[0], &values[2],
 236                                                         &values[4], &values[3], &values[5]);
 237
 238                                         if (count < 8)
 239                                                 fprintf(stderr, "\n3d-trans-load: warning: "
 240                                                                 "Missing args for 'E'\n");
 241
 242                                         if (width != result.scaled_width()
 243                                          || height != result.scaled_height()) {
 244                                                 fprintf(stderr, "\n3d-trans-load: Error: "
 245                                                                 "Scaled image width and/or height mismatch.");
 246                                         }
 247
 248                                         for (int i = 3; i < 6; i++) {
 249                                                 values [i] /= rtod_multiplier;
 250                                         }
 251
 252                                         result.e().set(values);
 253
 254                                         return result;
 255                                 }
 256                                 break;
 257                         default:
 258                                 fprintf(stderr,
 259                                         "\ntrans-load: Error in tload_first: unrecognized command '%s'\n",
 260                                         line);
 261                                 exit(1);
 262                 }
 263         }
 264
 265         /*
 266          * EOF reached: return default transformation.
 267          */
 268
 269         return result;
 270 }
 271
 272 /*
 273  * Load the next transformation from a transformation data file associated with
 274  * transformation data file structure T, or return the default transformation
 275  * if no transformation is available.
 276  *
 277  *      T is a pointer to the tload_t transformation data file structure.
 278  *
 279  *      IS_P is nonzero if a projective transformation is expected.
 280  *
 281  *      DEFAULT_TRANSFORM is the default transformation result.
 282  *
 283  *      IS_DEFAULT is used to signal a non-default transformation result.
 284  */
 285
 286 static inline pt tload_next(struct tload_t *t,
 287                 pt default_transform, int *is_default) {
 288
 289         pt result = default_transform;
 290
 291         *is_default = 1;
 292
 293         /*
 294          * Read each line of the file until we find a transformation.
 295          */
 296
 297         while (t && !feof(t->file)) {
 298                 char line[1024];
 299
 300                 if (!fgets(line, 1024, t->file))
 301                         return result;
 302
 303                 if (strlen(line) >= 1023) {
 304                         fprintf(stderr,
 305                                 "\ntrans-load: warning: line too long in input file\n");
 306                 }
 307
 308                 const double rtod_multiplier = 180 / M_PI;
 309
 310                 switch (line[0]) {
 311                         case ' ':
 312                         case 0xa:
 313                         case 0xd:
 314                         case '\t':
 315                         case '#':
 316                                 /* Comment or whitespace */
 317                                 break;
 318                         case 'D':
 319                         case 'd':
 320                                 /* Default transformation */
 321                                 return result;
 322                         case 'V':
 323                         case 'v':
 324                                 unsigned int count;
 325                                 double view_angle;
 326
 327                                 count = sscanf(line, "V %lf", &view_angle);
 328
 329                                 if (count < 1) {
 330                                         fprintf(stderr, "\n3d-trans-load: Error: "
 331                                                         "Malformed 'V' command.\n");
 332                                         exit(1);
 333                                 }
 334
 335                                 result.view_angle(view_angle / rtod_multiplier);
 336
 337                                 break;
 338                         case 'E':
 339                         case 'e':
 340                                 /* Euclidean transformation data */
 341                                 *is_default = 0;
 342                                 {
 343                                         double width, height;
 344                                         double values[6] = {0, 0, -1, 0, 0, 0};
 345                                         int count;
 346
 347                                         count = sscanf(line, "E %lf%lf%lf%lf%lf%lf%lf%lf",
 348                                                         &width, &height,
 349                                                         &values[1], &values[0], &values[2],
 350                                                         &values[4], &values[3], &values[5]);
 351
 352                                         if (count < 8)
 353                                                 fprintf(stderr, "\n3d-trans-load: warning: "
 354                                                                 "Missing args for 'E'\n");
 355
 356                                         if (width != result.scaled_width()
 357                                          || height != result.scaled_height()) {
 358                                                 fprintf(stderr, "\n3d-trans-load: Error: "
 359                                                                 "Scaled image width and/or height mismatch.");
 360                                         }
 361
 362                                         for (int i = 3; i < 6; i++) {
 363                                                 values [i] /= rtod_multiplier;
 364                                         }
 365
 366                                         result.e().set(values);
 367
 368                                         return result;
 369                                 }
 370                                 break;
 371                         default:
 372                                 fprintf(stderr,
 373                                         "\ntrans-load: Error in tload_next: unrecognized command '%s'\n",
 374                                         line);
 375                                 exit(1);
 376                 }
 377         }
 378
 379         return result;
 380 }
 381
 382 /*
 383  * Create a new tsave_t transformation data file structure, used for
 384  * writing data to transformation data files.
 385  */
 386
 387 static inline struct tsave_t *tsave_new(const char *filename) {
 388         FILE *file = fopen (filename, "w");
 389         struct tsave_t *result = NULL;
 390
 391         if (!file) {
 392                 fprintf(stderr, "tsave: Error: could not open transformation data file '%s'.", filename);
 393                 exit(1);
 394         }
 395
 396         result = (struct tsave_t *)
 397                 malloc(sizeof(struct tsave_t));
 398         result->filename = filename;
 399         result->file = file;
 400         result->orig = "unknown";
 401         result->target = "unknown";
 402
 403         fprintf(file, "# created by ALE 3D transformation file handler version %d\n",
 404                         D3_TFILE_VERSION);
 405
 406         fclose(file);
 407
 408         return result;
 409 }
 410
 411 /*
 412  * Save the first transformation to a transformation data file associated with
 413  * transformation data file structure T, or do nothing if T is NULL.  This
 414  * function also establishes the output file version.
 415  *
 416  *      OFFSET is the transformation to be saved.
 417  *
 418  *      IS_PROJECTIVE indicates whether to write a projective transformation.
 419  *
 420  */
 421
 422 static inline void tsave_first(struct tsave_t *t, pt offset) {
 423
 424         if (t == NULL)
 425                 return;
 426
 427         t->file = fopen(t->filename, "a");
 428
 429         tfile_output_version = 0;
 430
 431         fprintf(t->file, "# producing 3D transformation file syntax version %d\n", tfile_output_version);
 432         fprintf(t->file, "W %d\n", tfile_output_version);
 433
 434         // fprintf(t->file, "# Comment: Target output file is %s\n", t->target);
 435         // fprintf(t->file, "# Comment: Original frame is %s\n", t->orig);
 436
 437         const double rtod_multiplier = 180 / M_PI;
 438
 439         fprintf(t->file, "V %lf\n", (double) offset.view_angle() * rtod_multiplier);
 440
 441         fprintf(t->file, "E ");
 442         fprintf(t->file, "%f %f ", (double) offset.scaled_width(), (double) offset.scaled_height());
 443         fprintf(t->file, "%f ",    (double) offset.e().get_translation(1));
 444         fprintf(t->file, "%f ",    (double) offset.e().get_translation(0));
 445         fprintf(t->file, "%f ",    (double) offset.e().get_translation(2));
 446         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(1) * rtod_multiplier);
 447         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(0) * rtod_multiplier);
 448         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(2) * rtod_multiplier);
 449
 450         fprintf(t->file, "\n");
 451
 452         fclose(t->file);
 453 }
 454
 455 /*
 456  * Save the next transformation to a transformation data file associated with
 457  * transformation data file structure T, or do nothing if T is NULL.
 458  *
 459  *      OFFSET is the transformation to be saved.
 460  *
 461  *      IS_PROJECTIVE indicates whether to write a projective transformation.
 462  *
 463  */
 464
 465 static inline void tsave_next(struct tsave_t *t, pt offset) {
 466
 467         if (t == NULL)
 468                 return;
 469
 470         t->file = fopen(t->filename, "a");
 471
 472         const double rtod_multiplier = 180 / M_PI;
 473
 474         fprintf(t->file, "V %lf\n", (double) offset.view_angle() * rtod_multiplier);
 475
 476         fprintf(t->file, "E ");
 477         fprintf(t->file, "%f %f ", (double) offset.scaled_width(), (double) offset.scaled_height());
 478         fprintf(t->file, "%f ",    (double) offset.e().get_translation(1));
 479         fprintf(t->file, "%f ",    (double) offset.e().get_translation(0));
 480         fprintf(t->file, "%f ",    (double) offset.e().get_translation(2));
 481         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(1) * rtod_multiplier);
 482         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(0) * rtod_multiplier);
 483         fprintf(t->file, "%f ",    (double) offset.e().get_rotation(2) * rtod_multiplier);
 484
 485         fprintf(t->file, "\n");
 486
 487         fclose(t->file);
 488 }
 489
 490 /*
 491  * Write information to a transformation file indicating the target output
 492  * file.
 493  */
 494
 495 static inline void tsave_target(struct tsave_t *t, const char *filename) {
 496         if (t == NULL)
 497                 return;
 498
 499         t->target = filename;
 500         if (t != NULL) {
 501                 t->file = fopen(t->filename, "a");
 502
 503
 504                 fclose(t->file);
 505         }
 506 }
 507
 508 /*
 509  * Write information to a transformation data file indicating the filename
 510  * of the original frame (i.e. the first frame in the sequence of input
 511  * frames).
 512  */
 513
 514 static inline void tsave_orig(struct tsave_t *t, const char *filename) {
 515         if (t == NULL)
 516                 return;
 517
 518         t->orig = filename;
 519 }
 520
 521 /*
 522  * Write information to a transformation data file indicating the filename
 523  * of a supplemental frame (i.e. a frame in the sequence of input frames
 524  * that is not the first frame).
 525  */
 526
 527 static inline void tsave_info(struct tsave_t *t, const char *filename) {
 528         if (t != NULL) {
 529                 t->file = fopen(t->filename, "a");
 530
 531                 fprintf(t->file, "# Comment: Supplemental frame %s\n", filename);
 532
 533                 fclose(t->file);
 534         }
 535 }
 536
 537 /*
 538  * Write information to a transformation data file indicating the tonal
 539  * registration multiplier.
 540  */
 541
 542 static inline void tsave_trm(struct tsave_t *t, ale_real r, ale_real g, ale_real b) {
 543        if (t != NULL) {
 544                t->file = fopen(t->filename, "a");
 545
 546                fprintf(t->file, "# Comment: Exposure [r=%f g=%f b=%f]\n", (double) r, (double) g, (double) b);
 547
 548                fclose(t->file);
 549        }
 550 }
 551
 552 /*
 553  * Write information to a transformation data file indicating the average
 554  * pixel magnitude.
 555  */
 556
 557 static inline void tsave_apm(struct tsave_t *t, ale_real r, ale_real g, ale_real b) {
 558        if (t != NULL) {
 559                t->file = fopen(t->filename, "a");
 560
 561                fprintf(t->file, "# Comment: Avg magnitude [r=%f g=%f b=%f]\n", (double) r, (double) g, (double) b);
 562
 563                fclose(t->file);
 564        }
 565 }
 566
 567
 568 /*
 569  * Destroy a tload_t transformation data file structure.
 570  */
 571
 572 static inline void tload_delete(struct tload_t *victim) {
 573         if (victim)
 574                 fclose(victim->file);
 575         free(victim);
 576 }
 577
 578 /*
 579  * Destroy a tsave_t transformation data file structure.
 580  */
 581
 582 static inline void tsave_delete(struct tsave_t *victim) {
 583         free(victim);
 584 }
 585
 586 #endif