city_generator2

cg_ground.c (7091B)

---

 /* 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_ground.h"
 #include "cg_building.h"
 #include "cg_city.h"
 #include "cg_vertex_denoiser.h"
 #include "cg_stardis_model.h"
 
 #include <rsys/rsys.h>
 #include <rsys/dynamic_array_double.h>
 #include <rsys/str.h>
 
 #include <star/scad.h>
 
 #define GDEL(Tgt) \
   if(Tgt) SCAD(geometry_ref_put(Tgt)); \
   /* To avoid double delete, set to NULL after deletion */ \
   Tgt = NULL
 
 #define GPUSH(G) \
   ASSERT(G); \
   ERR(darray_geometries_push_back(&ground->boundaries, &(G))); \
   ERR(scad_geometry_ref_put(G)); /* Ownership is transfered to array */ \
   surface = NULL; \
   (G) = NULL;
 
 res_T
 ground_build_cad
   (struct mem_allocator* allocator,
    struct city* city)
 {
   res_T res = RES_OK;
   double origin[3];
   double extent[3];
   struct scad_geometry* bound = NULL;
   struct scad_geometry** list;
   struct scad_geometry* surface = NULL;
   struct scad_geometry* tmp = NULL;
   size_t i, count = 0;
   struct ground* ground;
 
   ASSERT(city);
 
   ground = &city->ground;
   origin[0] = city->lower[0];
   origin[1] = city->lower[1];
   origin[2] = -city->ground_depth;
 
   extent[0] = city->upper[0] - city->lower[0];
   extent[1] = city->upper[1] - city->lower[1];
   extent[2] = city->ground_depth;
 
   if(origin[2] > 0 || extent[0] < 0 || extent[1] < 0 || extent[2] < 0 ) {
     res = RES_BAD_ARG;
     goto error;
   }
 
   ERR(scad_add_box(NULL, origin, extent, &ground->box));
   ERR(scad_geometry_boundary(NULL, &ground->box, 1, &bound));
 
   ERR(scad_geometry_explode(bound, NULL, &list, &count));
   ERR(darray_geometries_reserve(&ground->boundaries, count));
 
   for(i = 0; i < count; i++) {
     double center[3];
     size_t center_n;
     double N[3];
 
     ERR(scad_geometry_get_count(list[i], &center_n));
     ASSERT(center_n == 1);
     ERR(scad_geometry_get_centerofmass(list[i], center));
     ERR(scad_geometry_normal(list[i], center, N, NULL, &surface));
 
     if (N[0] == 0 && N[1] == 0 && N[2] == -1) {
       ERR(scad_geometry_rename(surface, "ground_B_bottom"));
       ground->bottom = surface;
       GPUSH(surface);
     }
     else if (N[0] == 0 && N[1] == 0 && N[2] == 1) {
       struct scad_geometry** footprints =
         darray_geometries_data_get(&ground->footprints);
       size_t fpcount = darray_geometries_size_get(&ground->footprints);
       if(fpcount) {
         ERR(scad_cut_geometries("ground_B_top", &surface, 1, footprints, fpcount,
               &tmp));
         GDEL(surface);
         ground->top = tmp;
         GPUSH(tmp);
       } else {
         ERR(scad_geometry_rename(surface, "ground_B_top"));
         ground->top = surface;
         GPUSH(surface);
       }
     }
     else if (N[0] == -1 && N[1] == 0 && N[2] == 0) {
       ERR(scad_geometry_rename(surface, "ground_B_lateral_0"));
       GPUSH(surface);
     }
     else if (N[0] == 1 && N[1] == 0 && N[2] == 0) {
       ERR(scad_geometry_rename(surface, "ground_B_lateral_1"));
       GPUSH(surface);
     }
     else if (N[0] == 0 && N[1] == -1 && N[2] == 0) {
       ERR(scad_geometry_rename(surface, "ground_B_lateral_2"));
       GPUSH(surface);
     }
     else if (N[0] == 0 && N[1] == 1 && N[2] == 0) {
       ERR(scad_geometry_rename(surface, "ground_B_lateral_3"));
       GPUSH(surface);
     }
     else FATAL("Wrong ground box boundary.");
   }
 
 exit:
   for (i = 0; i < count; i++) {
     GDEL(list[i]);
   }
   MEM_RM(allocator, list);
   GDEL(surface);
   GDEL(tmp);
   GDEL(bound);
   return res;
 error:
   goto exit;
 }
 #undef GPUSH
 
 res_T
 ground_export_stl
   (struct city* city)
 {
   res_T res = RES_OK;
   struct ground* ground;
   struct vertex_denoiser* denoiser;
   struct mem_allocator* allocator;
   struct darray_double trg;
   const char* name;
   struct str filename;
   int binary;
   FILE* model = NULL;
   FILE* vars = NULL;
   const char* n;
   size_t i = 0;
   long model_count = 0;
 
   ASSERT(city);
   (void)model_count; /* To allow STARDIS_SOLID_ use */
   ground = &city->ground;
   binary = city->binary_export;
   denoiser = city->denoiser;
   allocator = city->allocator;
   darray_double_init(allocator, &trg);
   str_init(allocator, &filename);
   model = city->stardis_model;
   vars = city->set_vars;
 
   fprintf(model, "\n# GROUND\n");
   fprintf(vars, "\n# GROUND\n");
 
   for(i = 0; i < darray_geometries_size_get(&ground->boundaries); i++) {
     struct scad_geometry* b = darray_geometries_data_get(&ground->boundaries)[i];
     ERR(scad_geometry_get_name(b, &n));
     /* Boundary files */
     darray_double_clear(&trg);
     ERR(scad_stl_get_data(b, &trg));
     if(b == ground->top) {
       /* Add patches */
       ERR(darray_double_merge(&trg, &ground->ground_patches));
     }
     ERR(scad_geometry_get_name(b, &name));
     ERR(str_set(&filename, name));
     ERR(str_append(&filename, ".stl"));
     ERR(denoise_array(denoiser, &trg));
     ERR(scad_stl_data_write(&trg, str_cget(&filename),
         Scad_keep_normals_unchanged, binary));
     if(b == ground->bottom) {
       STARDIS_T_BOUND_2_model(ground_B_bottom, n);
     } else {
       if(b == ground->top) {
         STARDIS_H_BOUND_2_model(ground_B_top, n);
       }else {
         STARDIS_F_BOUND_2(ground_B_lateral, n);
       }
     }
     /* Also collect boundaries triangles into ground body */
     ERR(darray_double_merge(&ground->ground_building_connections, &trg));
   }
   ERR(denoise_array(denoiser, &ground->ground_building_connections));
   ERR(scad_stl_data_write(&ground->ground_building_connections, "ground_body.stl",
         Scad_force_normals_outward, binary));
 
   STARDIS_SOLID_2_model(ground_body, "ground_body");
 
 exit:
   darray_double_release(&trg);
   str_release(&filename);
   return res;
 error:
   goto exit;
 }
 
 void
 ground_init
   (struct mem_allocator* allocator,
    struct ground* ground)
 {
   ground->box = NULL;
   darray_double_init(allocator, &ground->ground_building_connections);
   darray_double_init(allocator, &ground->ground_patches);
   darray_geometries_init(allocator, &ground->footprints);
   darray_geometries_init(allocator, &ground->boundaries);
 }
 
 void
 ground_clear
   (struct ground* ground)
 {
   GDEL(ground->box);
   darray_geometries_purge(&ground->footprints);
   darray_geometries_purge(&ground->boundaries);
   darray_double_purge(&ground->ground_building_connections);
   darray_double_purge(&ground->ground_patches);
 }
 
 #undef GDEL