star-cem

scem_main.c (5385B)

---

 /* Copyright (C) 2025 |Méso|Star> (contact@meso-star.com)
  *
  * This program is free software: you can redismeteobute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is dismeteobuted in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>. */
 
 #define _XOPEN_SOURCE /* strptime support */
 #define _POSIX_C_SOURCE 200112L /* getopt support */
 
 #include "scem.h"
 
 #include <rsys/rsys.h>
 #include <rsys/cstr.h>
 #include <rsys/mem_allocator.h>
 
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h> /* getopt */
 
 struct args {
   struct scem_location pos;
   struct tm time; /* In UTC+00:00 */
   enum scem_sun_algo algo;
   int radian; /* Sun position in radians instead of degrees */
   int verbose;
   int quit;
   int no_dir_output;
   int vec_output;
 };
 static const struct args ARGS_DEFAULT = {
   SCEM_LOCATION_NULL__, {0}, SCEM_SUN_MEEUS, 0, 0, 0, 0, 0
 };
 
 /*******************************************************************************
  * Helper functions
  ******************************************************************************/
 static INLINE void
 usage(FILE* stream)
 {
   fprintf(stream,
     "usage: scem [-DhrVv] [-a algo] [-d utc_date] latitude longitude\n");
 }
 
 static res_T
 parse_algo(const char* str, enum scem_sun_algo* algo)
 {
   ASSERT(str && algo);
 
   if(!strcmp(str, "meeus")) {
     *algo = SCEM_SUN_MEEUS;
   } else if(!strcmp(str, "psa")) {
     *algo = SCEM_SUN_PSA;
   } else {
     return RES_BAD_ARG;
   }
   return RES_OK;
 }
 
 static res_T
 parse_date(const char* str, struct tm* time)
 {
   char *p;
   ASSERT(str && time);
 
   p = strptime(str, "%Y-%m-%dT%H:%M:%S\n", time);
   if(!p || *p != '\0') { /* strptime failed or trailing chars */
     return RES_BAD_ARG;
   } else {
     return RES_OK;
   }
 }
 
 static res_T
 parse_dbl
   (const char* str,
    const double min,
    const double max,
    double* out_dbl) /* In [min, max] */
 {
   double dbl = 0;
   res_T res = RES_OK;
   ASSERT(str && out_dbl && min <= max);
 
   if((res = cstr_to_double(str, &dbl)) != RES_OK) return res;
   if(dbl < min || dbl > max) {
     fprintf(stderr, "scem: value not in range: %g [%g %g]\n", dbl, min, max);
     return RES_BAD_ARG;
   }
 
   *out_dbl = dbl;
   return RES_OK;
 }
 
 static res_T
 get_current_date(struct tm* date)
 {
   time_t epoch;
   ASSERT(date);
 
   epoch = time(NULL);
   if(epoch == (time_t)-1) {
     fprintf(stderr, "scem: error in querying local time\n");
     return RES_BAD_ARG;
   }
 
   *date = *gmtime(&epoch);
   return RES_OK;
 }
 
 static res_T
 args_init(struct args* args, int argc, char** argv)
 {
   int opt = 0;
   res_T res = RES_OK;
 
   *args = ARGS_DEFAULT;
 
   if((res = get_current_date(&args->time)) != RES_OK) goto error;
 
   /* Don't process the last 2 args as options, they are lat and long */
   while((opt = getopt(argc - 2, argv, "a:Dd:hVvr")) != -1) {
     switch(opt) {
       case 'a': res = parse_algo(optarg, &args->algo); break;
       case 'D': args->no_dir_output = 1; break;
       case 'd': res = parse_date(optarg, &args->time); break;
       case 'h': usage(stdout); args->quit = 1; goto exit;
       case 'V': args->vec_output = 1; break;
       case 'v': args->verbose = 1; break;
       case 'r': args->radian = 1; break;
       default: res = RES_BAD_ARG; break;
     }
     if(res != RES_OK) {
       if(optarg) {
         fprintf(stderr, "scem: invalid option argument '%s' -- '%c'\n",
           optarg, opt);
       }
       goto error;
     }
   }
 
   /* Is location missing? */
   if(argc - optind < 2) { res = RES_BAD_ARG; goto error; }
 
   res = parse_dbl(argv[optind+0], -90, 90, &args->pos.latitude);
   if(res != RES_OK) goto error;
   res = parse_dbl(argv[optind+1], -180, 180, &args->pos.longitude);
   if(res != RES_OK) goto error;
 exit:
   return res;
 error:
   usage(stderr);
   goto exit;
 }
 
 /*******************************************************************************
  * The program
  ******************************************************************************/
 int
 main(int argc, char** argv)
 {
   struct args args = ARGS_DEFAULT;
   struct scem_sun_pos pos = SCEM_SUN_POS_NULL;
   double sun_dir[3];
   int err = 0;
   res_T res = RES_OK;
 
   if((res = args_init(&args, argc, argv)) != RES_OK) goto error;
   if(args.quit) goto exit;
 
   if(args.verbose) fprintf(stderr, "%s", asctime(&args.time));
 
   res = scem_sun_position_from_earth(&args.time, &args.pos, args.algo, &pos);
   if(res != RES_OK) {
     fprintf(stderr, "scem: error in computing the position of sun -- %s\n",
       res_to_cstr(res));
     goto error;
   }
 
   if(!args.no_dir_output) {
     if(args.radian) {
       printf("%g %g\n", pos.elevation, pos.azimuth);
     } else {
       printf("%g %g\n", MRAD2DEG(pos.elevation), MRAD2DEG(pos.azimuth));
     }
   }
   if(args.vec_output) {
     res = scem_sun_position_to_sun_vector(&pos, sun_dir);
     if(res != RES_OK) goto error;
     fprintf(stderr, "%g %g %g\n", SPLIT3(sun_dir));
   }
 
 exit:
   CHK(mem_allocated_size() == 0);
   return err;
 error:
   err = 1;
   goto exit;
 }