src/cavern.c

   1 /* cavern.c
   2  * SURVEX Cave surveying software: data reduction main and related functions
   3  * Copyright (C) 1991-2024 Olly Betts
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19
  20 #include <config.h>
  21
  22 #define MSG_SETUP_PROJ_SEARCH_PATH 1
  23
  24 #include <limits.h>
  25 #include <stdlib.h>
  26 #include <time.h>
  27
  28 #include "cavern.h"
  29 #include "cmdline.h"
  30 #include "commands.h"
  31 #include "date.h"
  32 #include "datain.h"
  33 #include "debug.h"
  34 #include "message.h"
  35 #include "filename.h"
  36 #include "filelist.h"
  37 #include "img_hosted.h"
  38 #include "listpos.h"
  39 #include "netbits.h"
  40 #include "netskel.h"
  41 #include "out.h"
  42 #include "str.h"
  43 #include "validate.h"
  44 #include "whichos.h"
  45
  46 #if OS_WIN32
  47 # include <conio.h> /* for _kbhit() and _getch() */
  48 #endif
  49
  50 /* Globals */
  51 node *fixedlist = NULL; // Fixed points
  52 node *stnlist = NULL; // Unfixed stations
  53 settings *pcs;
  54 prefix *root;
  55 prefix *anon_list = NULL;
  56 long cLegs, cStns;
  57 long cComponents;
  58 bool fExportUsed = false;
  59 char * proj_str_out = NULL;
  60 PJ * pj_cached = NULL;
  61
  62 FILE *fhErrStat = NULL;
  63 img *pimg = NULL;
  64 bool fQuiet = false; /* just show brief summary + errors */
  65 bool fMute = false; /* just show errors */
  66 bool fSuppress = false; /* only output 3d file */
  67 static bool fLog = false; /* stdout to .log file */
  68 static bool f_warnings_are_errors = false; /* turn warnings into errors */
  69
  70 nosurveylink *nosurveyhead;
  71
  72 real totadj, total, totplan, totvert;
  73 real min[9], max[9];
  74 prefix *pfxHi[9], *pfxLo[9];
  75
  76 string survey_title = S_INIT;
  77
  78 bool fExplicitTitle = false;
  79
  80 char *fnm_output_base = NULL;
  81 int fnm_output_base_is_dir = 0;
  82
  83 lrudlist * model = NULL;
  84 lrud ** next_lrud = NULL;
  85
  86 char output_separator = '.';
  87
  88 static void do_stats(void);
  89
  90 static const struct option long_opts[] = {
  91    /* const char *name; int has_arg (0 no_argument, 1 required_*, 2 optional_*); int *flag; int val; */
  92    {"percentage", no_argument, 0, 'p'},
  93    /* Ignore for compatibility with older versions. */
  94    {"no-percentage", no_argument, 0, 0},
  95    {"output", required_argument, 0, 'o'},
  96    {"quiet", no_argument, 0, 'q'},
  97    {"no-auxiliary-files", no_argument, 0, 's'},
  98    {"warnings-are-errors", no_argument, 0, 'w'},
  99    {"log", no_argument, 0, 1},
 100    {"3d-version", required_argument, 0, 'v'},
 101 #if OS_WIN32
 102    {"pause", no_argument, 0, 2},
 103 #endif
 104    {"help", no_argument, 0, HLP_HELP},
 105    {"version", no_argument, 0, HLP_VERSION},
 106    {0, 0, 0, 0}
 107 };
 108
 109 #define short_opts "pao:qsv:wz:"
 110
 111 static struct help_msg help[] = {
 112 /*                              <-- */
 113    /* TRANSLATORS: --help output for cavern --output option */
 114    {HLP_ENCODELONG(2),        /*set location for output files*/162, 0, 0},
 115    /* TRANSLATORS: --help output for cavern --quiet option */
 116    {HLP_ENCODELONG(3),        /*only show brief summary (-qq for errors only)*/163, 0, 0},
 117    /* TRANSLATORS: --help output for cavern --no-auxiliary-files option */
 118    {HLP_ENCODELONG(4),        /*do not create .err file*/164, 0, 0},
 119    /* TRANSLATORS: --help output for cavern --warnings-are-errors option */
 120    {HLP_ENCODELONG(5),        /*turn warnings into errors*/165, 0, 0},
 121    /* TRANSLATORS: --help output for cavern --log option */
 122    {HLP_ENCODELONG(6),        /*log output to .log file*/170, 0, 0},
 123    /* TRANSLATORS: --help output for cavern --3d-version option */
 124    {HLP_ENCODELONG(7),        /*specify the 3d file format version to output*/171, 0, 0},
 125  /*{'z',                        "set optimizations for network reduction"},*/
 126    {0, 0, 0, 0}
 127 };
 128
 129 /* atexit functions */
 130 static void
 131 delete_output_on_error(void)
 132 {
 133    if (msg_errors || (f_warnings_are_errors && msg_warnings))
 134       filename_delete_output();
 135 }
 136
 137 #if OS_WIN32
 138 static void
 139 pause_on_exit(void)
 140 {
 141    while (_kbhit()) _getch();
 142    _getch();
 143 }
 144 #endif
 145
 146 int current_days_since_1900;
 147
 148 static void discarding_proj_logger(void *ctx, int level, const char *message) {
 149     (void)ctx;
 150     (void)level;
 151     (void)message;
 152 }
 153
 154 extern int
 155 main(int argc, char **argv)
 156 {
 157    int d;
 158    time_t tmUserStart = time(NULL);
 159    clock_t tmCPUStart = clock();
 160    {
 161        /* FIXME: localtime? */
 162        struct tm * t = localtime(&tmUserStart);
 163        int y = t->tm_year + 1900;
 164        current_days_since_1900 = days_since_1900(y, t->tm_mon + 1, t->tm_mday);
 165    }
 166
 167    /* Always buffer by line for aven's benefit. */
 168    setvbuf(stdout, NULL, _IOLBF, 0);
 169
 170    /* Prevent stderr spew from PROJ. */
 171    proj_log_func(PJ_DEFAULT_CTX, NULL, discarding_proj_logger);
 172
 173    msg_init(argv);
 174
 175    pcs = osnew(settings);
 176    pcs->next = NULL;
 177    pcs->from_equals_to_is_only_a_warning = false;
 178    pcs->Translate = ((short*) osmalloc(ossizeof(short) * 257)) + 1;
 179    pcs->meta = NULL;
 180    pcs->proj_str = NULL;
 181    pcs->declination = HUGE_REAL;
 182    pcs->convergence = HUGE_REAL;
 183    pcs->input_convergence = HUGE_REAL;
 184    pcs->dec_filename = NULL;
 185    pcs->dec_line = 0;
 186    pcs->dec_context = NULL;
 187    pcs->dec_lat = HUGE_VAL;
 188    pcs->dec_lon = HUGE_VAL;
 189    pcs->dec_alt = HUGE_VAL;
 190    pcs->min_declination = HUGE_VAL;
 191    pcs->max_declination = -HUGE_VAL;
 192    pcs->cartesian_north = TRUE_NORTH;
 193    pcs->cartesian_rotation = 0.0;
 194
 195    /* Set up root of prefix hierarchy */
 196    root = osnew(prefix);
 197    root->up = root->right = root->down = NULL;
 198    root->stn = NULL;
 199    root->pos = NULL;
 200    root->ident.p = NULL;
 201    root->min_export = root->max_export = 0;
 202    root->sflags = BIT(SFLAGS_SURVEY);
 203    root->filename = NULL;
 204
 205    nosurveyhead = NULL;
 206
 207    fixedlist = NULL;
 208    stnlist = NULL;
 209    cLegs = cStns = cComponents = 0;
 210    totadj = total = totplan = totvert = 0.0;
 211
 212    for (d = 0; d < 9; d++) {
 213       min[d] = HUGE_REAL;
 214       max[d] = -HUGE_REAL;
 215       pfxHi[d] = pfxLo[d] = NULL;
 216    }
 217
 218    // TRANSLATORS: Here "survey" is a "cave map" rather than list of questions
 219    // - it should be translated to the terminology that cavers using the
 220    // language would use.
 221    //
 222    // Part of cavern --help
 223    cmdline_set_syntax_message(/*[SURVEY_DATA_FILE]*/507, 0, NULL);
 224    /* at least one argument must be given */
 225    cmdline_init(argc, argv, short_opts, long_opts, NULL, help, 1, -1);
 226    while (1) {
 227       int opt = cmdline_getopt();
 228       if (opt == EOF) break;
 229       switch (opt) {
 230        case 'p':
 231          /* Ignore for compatibility with older versions. */
 232          break;
 233        case 'o': {
 234          osfree(fnm_output_base); /* in case of multiple -o options */
 235          /* can be a directory (in which case use basename of leaf input)
 236           * or a file (in which case just trim the extension off) */
 237          if (fDirectory(optarg)) {
 238             /* this is a little tricky - we need to note the path here,
 239              * and then add the leaf later on (in datain.c) */
 240             fnm_output_base = base_from_fnm(optarg);
 241             fnm_output_base_is_dir = 1;
 242          } else {
 243             fnm_output_base = base_from_fnm(optarg);
 244          }
 245          break;
 246        }
 247        case 'q':
 248          if (fQuiet) fMute = 1;
 249          fQuiet = 1;
 250          break;
 251        case 's':
 252          fSuppress = 1;
 253          break;
 254        case 'v': {
 255          int v = atoi(optarg);
 256          if (v < IMG_VERSION_MIN || v > IMG_VERSION_MAX)
 257             fatalerror(/*3d file format versions %d to %d supported*/88,
 258                        IMG_VERSION_MIN, IMG_VERSION_MAX);
 259          img_output_version = v;
 260          break;
 261        }
 262        case 'w':
 263          f_warnings_are_errors = 1;
 264          break;
 265        case 'z': {
 266          /* Control which network optimisations are used (development tool) */
 267          static int first_opt_z = 1;
 268          char c;
 269          if (first_opt_z) {
 270             optimize = 0;
 271             first_opt_z = 0;
 272          }
 273          /* Lollipops, Parallel legs, Iterate mx, Delta* */
 274          while ((c = *optarg++) != '\0')
 275             if (islower((unsigned char)c)) optimize |= BITA(c);
 276          break;
 277        case 1:
 278          fLog = true;
 279          break;
 280 #if OS_WIN32
 281        case 2:
 282          atexit(pause_on_exit);
 283          break;
 284 #endif
 285        }
 286       }
 287    }
 288
 289    if (fLog) {
 290       char *fnm;
 291       if (!fnm_output_base) {
 292          char *p;
 293          p = baseleaf_from_fnm(argv[optind]);
 294          fnm = add_ext(p, EXT_LOG);
 295          osfree(p);
 296       } else if (fnm_output_base_is_dir) {
 297          char *p;
 298          fnm = baseleaf_from_fnm(argv[optind]);
 299          p = use_path(fnm_output_base, fnm);
 300          osfree(fnm);
 301          fnm = add_ext(p, EXT_LOG);
 302          osfree(p);
 303       } else {
 304          fnm = add_ext(fnm_output_base, EXT_LOG);
 305       }
 306
 307       if (!freopen(fnm, "w", stdout))
 308          fatalerror(/*Failed to open output file “%s”*/47, fnm);
 309
 310       osfree(fnm);
 311    }
 312
 313    if (!fMute) {
 314       const char *p = COPYRIGHT_MSG;
 315       puts(PRETTYPACKAGE" "VERSION);
 316       while (1) {
 317           const char *q = p;
 318           p = strstr(p, "(C)");
 319           if (p == NULL) {
 320               puts(q);
 321               break;
 322           }
 323           fwrite(q, 1, p - q, stdout);
 324           fputs(msg(/*©*/0), stdout);
 325           p += 3;
 326       }
 327    }
 328
 329    atexit(delete_output_on_error);
 330
 331    /* end of options, now process data files */
 332    while (argv[optind]) {
 333       const char *fnm = argv[optind];
 334
 335       if (!fExplicitTitle) {
 336           char *lf = baseleaf_from_fnm(fnm);
 337           if (s_empty(&survey_title)) {
 338               s_donate(&survey_title, lf);
 339           } else {
 340               s_appendch(&survey_title, ' ');
 341               s_append(&survey_title, lf);
 342               osfree(lf);
 343           }
 344       }
 345
 346       /* Select defaults settings */
 347       default_all(pcs);
 348       data_file(NULL, fnm); /* first argument is current path */
 349
 350       optind++;
 351    }
 352
 353    validate();
 354
 355    report_declination(pcs);
 356
 357    solve_network(); /* Find coordinates of all points */
 358    validate();
 359
 360    /* close .3d file */
 361    if (!img_close(pimg)) {
 362       char *fnm = add_ext(fnm_output_base, EXT_SVX_3D);
 363       fatalerror(img_error2msg(img_error()), fnm);
 364    }
 365    if (fhErrStat) safe_fclose(fhErrStat);
 366
 367    out_current_action(msg(/*Calculating statistics*/120));
 368    if (!fMute) do_stats();
 369    if (!fQuiet) {
 370       /* clock() typically wraps after 72 minutes, but there doesn't seem
 371        * to be a better way.  Still 72 minutes means some cave!
 372        * We detect if clock() could have wrapped and suppress CPU time
 373        * printing in this case.
 374        */
 375       double tmUser = difftime(time(NULL), tmUserStart);
 376       double tmCPU;
 377       clock_t now = clock();
 378 #define CLOCK_T_WRAP \
 379         (sizeof(clock_t)<sizeof(long)?(1ul << (CHAR_BIT * sizeof(clock_t))):0)
 380       tmCPU = (now - (unsigned long)tmCPUStart)
 381          / (double)CLOCKS_PER_SEC;
 382       if (now < tmCPUStart)
 383          tmCPU += CLOCK_T_WRAP / (double)CLOCKS_PER_SEC;
 384       if (tmUser >= tmCPU + CLOCK_T_WRAP / (double)CLOCKS_PER_SEC)
 385          tmCPU = 0;
 386
 387       /* tmUser is integer, tmCPU not - equivalent to (ceil(tmCPU) >= tmUser) */
 388       if (tmCPU + 1 > tmUser) {
 389          printf(msg(/*CPU time used %5.2fs*/140), tmCPU);
 390       } else if (tmCPU == 0) {
 391          if (tmUser != 0.0) {
 392             printf(msg(/*Time used %5.2fs*/141), tmUser);
 393          } else {
 394             fputs(msg(/*Time used unavailable*/142), stdout);
 395          }
 396       } else {
 397          printf(msg(/*Time used %5.2fs (%5.2fs CPU time)*/143), tmUser, tmCPU);
 398       }
 399       putnl();
 400    }
 401    if (msg_warnings || msg_errors) {
 402       if (msg_errors || (f_warnings_are_errors && msg_warnings)) {
 403          printf(msg(/*There were %d warning(s) and %d error(s) - no output files produced.*/113),
 404                 msg_warnings, msg_errors);
 405          putnl();
 406          return EXIT_FAILURE;
 407       }
 408       printf(msg(/*There were %d warning(s).*/16), msg_warnings);
 409       putnl();
 410    }
 411    return EXIT_SUCCESS;
 412 }
 413
 414 static void
 415 do_range(int d, int msgno, real length_factor, const char * units)
 416 {
 417    if (d < 3) {
 418       /* If the bound including anonymous stations is at an anonymous station
 419        * but the bound only considering named stations is the same, use the
 420        * named station for the anonymous bound too.
 421        */
 422       if (TSTBIT(pfxHi[d]->sflags, SFLAGS_ANON) && max[d] == max[d + 3]) {
 423          pfxHi[d] = pfxHi[d + 3];
 424       }
 425       if (TSTBIT(pfxLo[d]->sflags, SFLAGS_ANON) && min[d] == min[d + 3]) {
 426          pfxLo[d] = pfxLo[d + 3];
 427       }
 428    }
 429
 430    /* sprint_prefix uses a single buffer, so to report two stations in one
 431     * message we need to make a temporary copy of the string for one of them.
 432     */
 433    char * pfx_hi = osstrdup(sprint_prefix(pfxHi[d]));
 434    char * pfx_lo = sprint_prefix(pfxLo[d]);
 435    real hi = max[d] * length_factor;
 436    real lo = min[d] * length_factor;
 437    printf(msg(msgno), hi - lo, units, pfx_hi, hi, units, pfx_lo, lo, units);
 438    osfree(pfx_hi);
 439    putnl();
 440
 441    /* Range without anonymous stations at offset 3. */
 442    if (d < 3 && (pfxHi[d] != pfxHi[d + 3] || pfxLo[d] != pfxLo[d + 3])) {
 443       do_range(d + 3, msgno, length_factor, units);
 444    }
 445 }
 446
 447 static void
 448 do_stats(void)
 449 {
 450    long cLoops = cComponents + cLegs - cStns;
 451
 452    putnl();
 453
 454    if (proj_str_out) {
 455        prefix *name_min = NULL;
 456        prefix *name_max = NULL;
 457        double convergence_min = HUGE_VAL;
 458        double convergence_max = -HUGE_VAL;
 459        prefix **pfx = pfxLo;
 460        for (int bound = 0; bound < 2; ++bound) {
 461            for (int d = 6; d <= 9; ++d) {
 462                if (pfx[d]) {
 463                    pos *p = pfx[d]->pos;
 464                    double convergence = calculate_convergence_xy(proj_str_out,
 465                                                                  p->p[0],
 466                                                                  p->p[1],
 467                                                                  p->p[2]);
 468                    if (convergence < convergence_min) {
 469                        convergence_min = convergence;
 470                        name_min = pfx[d];
 471                    }
 472                    if (convergence > convergence_max) {
 473                        convergence_max = convergence;
 474                        name_max = pfx[d];
 475                    }
 476                }
 477            }
 478            pfx = pfxHi;
 479        }
 480        if (name_min && name_max) {
 481            const char* deg_sign = msg(/*°*/344);
 482            /* sprint_prefix uses a single buffer, so to report two stations in
 483             * one message we need to make a temporary copy of the string for
 484             * one of them.
 485             */
 486            char *pfx_hi = osstrdup(sprint_prefix(name_max));
 487            char *pfx_lo = sprint_prefix(name_min);
 488            // TRANSLATORS: Cavern computes the grid convergence at the
 489            // representative location(s) specified by the
 490            // `*declination auto` command(s).  The convergence values
 491            // for the most N, S, E and W survey stations with legs
 492            // attached are also computed and the range of these values
 493            // is reported in this message.  It's approximate because the
 494            // min or max convergence could actually be beyond this range
 495            // but it's unlikely to be very wrong.
 496            //
 497            // Each %.1f%s will be replaced with a convergence angle (e.g.
 498            // 0.9°) and the following %s with the station name where that
 499            // convergence angle was computed.
 500            printf(msg(/*Approximate full range of grid convergence: %.1f%s at %s to %.1f%s at %s\n*/531),
 501                   deg(convergence_min), deg_sign, pfx_lo,
 502                   deg(convergence_max), deg_sign, pfx_hi);
 503            osfree(pfx_hi);
 504        }
 505    }
 506
 507    if (cStns == 1) {
 508       fputs(msg(/*Survey contains 1 survey station,*/172), stdout);
 509    } else {
 510       printf(msg(/*Survey contains %ld survey stations,*/173), cStns);
 511    }
 512
 513    if (cLegs == 1) {
 514       fputs(msg(/* joined by 1 leg.*/174), stdout);
 515    } else {
 516       printf(msg(/* joined by %ld legs.*/175), cLegs);
 517    }
 518
 519    putnl();
 520
 521    if (cLoops == 1) {
 522       fputs(msg(/*There is 1 loop.*/138), stdout);
 523    } else {
 524       printf(msg(/*There are %ld loops.*/139), cLoops);
 525    }
 526
 527    putnl();
 528
 529    if (cComponents != 1) {
 530       /* TRANSLATORS: "Connected component" in the graph theory sense - it
 531        * means there are %ld bits of survey with no connections between them.
 532        * This message is only used if there are more than 1. */
 533       printf(msg(/*Survey has %ld connected components.*/178), cComponents);
 534       putnl();
 535    }
 536
 537    int length_units = get_length_units(Q_LENGTH);
 538    const char * units = get_units_string(length_units);
 539    real length_factor = 1.0 / get_units_factor(length_units);
 540
 541    printf(msg(/*Total length of survey legs = %7.2f%s (%7.2f%s adjusted)*/132),
 542           total * length_factor, units, totadj * length_factor, units);
 543    putnl();
 544    printf(msg(/*Total plan length of survey legs = %7.2f%s*/133),
 545           totplan * length_factor, units);
 546    putnl();
 547    printf(msg(/*Total vertical length of survey legs = %7.2f%s*/134),
 548           totvert * length_factor, units);
 549    putnl();
 550
 551    /* If there's no underground survey, we've no ranges */
 552    if (pfxHi[0]) {
 553       /* TRANSLATORS: numbers are altitudes of highest and lowest stations */
 554       do_range(2, /*Vertical range = %4.2f%s (from %s at %4.2f%s to %s at %4.2f%s)*/135,
 555                length_factor, units);
 556       /* TRANSLATORS: c.f. previous message */
 557       do_range(1, /*North-South range = %4.2f%s (from %s at %4.2f%s to %s at %4.2f%s)*/136,
 558                length_factor, units);
 559       /* TRANSLATORS: c.f. previous two messages */
 560       do_range(0, /*East-West range = %4.2f%s (from %s at %4.2f%s to %s at %4.2f%s)*/137,
 561                length_factor, units);
 562    }
 563
 564    print_node_stats();
 565    /* Also, could give:
 566     *  # nodes stations (ie have other than two references or are fixed)
 567     *  # fixed stations (list of?)
 568     */
 569 }