src/cavern.c

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