city_generator2

cg_main.c (6569B)

---

 /* Copyright (C) 2022 Université de Pau et des Pays de l'Adour UPPA
  * Copyright (C) 2022 CNRS
  * Copyright (C) 2022 Sorbonne Université
  * Copyright (C) 2022 Université Paul Sabatier
  * Copyright (C) 2022 |Meso|Star> (contact@meso-star.com)
  *
  * This program is free software: you can redistribute 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 distributed 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/>. */
 
 #include "cg.h"
 #include "cg_args.h"
 #include "cg_building.h"
 #include "cg_city.h"
 #include "cg_city_parsing.h"
 #include "cg_catalog.h"
 #include "cg_catalog_parsing.h"
 #include "cg_vertex_denoiser.h"
 #include "cg_cyaml.h"
 
 #include <rsys/rsys.h>
 #include <rsys/clock_time.h>
 #include <rsys/logger.h>
 #include <rsys/mem_allocator.h>
 #include <star/scad.h>
 
 static int
 check_memory_allocator(struct mem_allocator* allocator) {
   if(MEM_ALLOCATED_SIZE(allocator)) {
     char dump[4096];
     MEM_DUMP(allocator, dump, sizeof(dump)/sizeof(char));
     fprintf(stderr, "%s\n", dump);
     fprintf(stderr, "Memory leaks.\n");
     return 1;
   }
   return 0;
 }
 
 static void cg_log
   (enum cyaml_log_e level,
    void *_ctx,
    const char *fmt,
    va_list args)
 {
   struct logger* logger = (struct logger*)_ctx;
   enum log_type type;
   ASSERT(logger && fmt);
 
   switch(level) {
     case CYAML_LOG_ERROR: type = LOG_ERROR; break;
     case CYAML_LOG_WARNING: type = LOG_WARNING; break;
     case CYAML_LOG_NOTICE: type = LOG_OUTPUT; break;
     default: return; /* Do not log this level of messages */
   }
   logger_vprint(logger, type, fmt, args);
 }
 
 static void* cg_mem
   (void *ctx,
    void *ptr,
    size_t size)
 {
   struct mem_allocator* allocator = (struct mem_allocator*)ctx;
   ASSERT(allocator);
   if(size == 0) {
     /* free() request */
     MEM_RM(allocator, ptr);
     return NULL;
   } else {
     return MEM_REALLOC(allocator, ptr, size);
   }
 }
 
 int main
   (int argc, char** argv)
 {
   int err = EXIT_SUCCESS;
   res_T res = RES_OK;
   struct args* args = NULL;
   struct city* city = NULL;
   struct logger logger;
   struct mem_allocator allocator;
   struct parsed_city* parsed_city = NULL;
   struct parsed_catalog* parsed_catalog = NULL;
   struct catalog* catalog = NULL;
   int logger_initialized = 0, allocator_initialized = 0;
   const struct cyaml_config config = {
     .log_fn = cg_log,
     .log_ctx = &logger,
     .mem_fn = cg_mem,
     .mem_ctx = &allocator,
     .log_level = CYAML_LOG_WARNING, /* Logging errors and warnings only. */
     .flags = CYAML_CFG_DEFAULT,
   };
   struct time t0, dt;
   char buf[128];
 
   time_current(&t0);
   /* init allocator and logger */
   ERR(mem_init_proxy_allocator(&allocator, &mem_default_allocator));
   allocator_initialized = 1;
   ERR(logger_init(&allocator, &logger));
   logger_initialized = 1;
 
   /* Active logging for args parsing */
   logger_set_stream(&logger, LOG_OUTPUT, log_prt_fn, NULL);
   logger_set_stream(&logger, LOG_WARNING, log_warn_fn, NULL);
   logger_set_stream(&logger, LOG_ERROR, log_err_fn, NULL);
 
   /* parse command line */
   ERR(parse_args(&allocator, &logger, argc, argv, &args));
   if(args->print_help) {
     short_help();
     goto exit;
   }
   else if(args->print_version) {
     print_version();
     goto exit;
   }
 
   /* Deactivate some logging according to the -V arg */
   if(args->verbosity_level < 1)
     logger_set_stream(&logger, LOG_ERROR, NULL, NULL);
   if(args->verbosity_level < 2)
     logger_set_stream(&logger, LOG_WARNING, NULL, NULL);
   if(args->verbosity_level < 3)
     logger_set_stream(&logger, LOG_OUTPUT, NULL, NULL);
 
 #ifndef NDEBUG
   if(args->verbosity_level == 3) {
     logger_print(&logger, LOG_WARNING,
         "Running debug binary with increased verbosity.\n");
   } else {
     logger_print(&logger, LOG_WARNING,
         "Running debug binary.\n");
   }
 #endif
 
   /* Parse catalog.
    * No semantic validation is done at this stage */
   ERR(parse_catalog(&args->catalog_files, &allocator, &logger, &config,
         &parsed_catalog));
 
   /* Create catalog from parsed data.
    * Semantic validation is done along the process as well as the emission of
    * informative logs */
   ERR(create_catalog(&allocator, &logger, parsed_catalog, &catalog));
   release_parsed_catalog(&config, parsed_catalog);
   parsed_catalog = NULL;
 
   /* Parse city description.
    * No semantic validation is done at this stage */
   ERR(parse_city(args->city_filename, &allocator, &logger, &config, &parsed_city));
 
   /* Create city with parsed data.
    * Semantic validation is done along the process as well as the emission of
    * informative logs */
   ERR(create_city(&allocator, &logger, args, parsed_city, catalog, &city));
   release_parsed_city(&config, parsed_city);
   parsed_city = NULL;
   release_args(args);
   args = NULL;
 
   ERR(city_cad_build(city));
   /* As buildings can be removed at the CAD generation step, ground CAD must be
    * generated after buildings CAD */
   ERR(city_ground_build(city));
 
 exit:
   if(logger_initialized && city) {
     size_t count, denoised_count;
     count = vertex_denoiser_get_count(city->denoiser);
     denoised_count = vertex_denoiser_get_denoised_count(city->denoiser);
     if(denoised_count > 0) {
       logger_print(&logger, LOG_OUTPUT, "Denoised %lu / %lu vertices.\n",
           denoised_count, count);
     }
     time_sub(&dt, time_current(&dt), &t0);
     time_dump(&dt, TIME_MIN | TIME_SEC, NULL, buf, sizeof(buf));
     logger_print(&logger, LOG_OUTPUT, "Total run time: %s.\n", buf);
   }
   release_city(city);
   release_catalog(catalog);
   if(args) release_args(args);
   if(logger_initialized) logger_release(&logger);
   if(allocator_initialized) {
     if(check_memory_allocator(&allocator)) err = EXIT_FAILURE;
     mem_shutdown_proxy_allocator(&allocator);
     CHK(mem_allocated_size() == 0);
   }
   return err;
 error:
   release_parsed_catalog(&config, parsed_catalog);
   release_parsed_city(&config, parsed_city);
   err = EXIT_FAILURE;
   if(logger_initialized) {
     logger_print(&logger, LOG_ERROR, "City generator failed.\n");
     if(city && !city->keep_running_on_errors)
       logger_print(&logger, LOG_ERROR, "Try to re-run with option -k.\n");
   }
   goto exit;
 }