SplitTris/splittris.cxx

   1 // splittris.cxx -- read in a .ele/.node file pair generated by the
   2 //                  triangle program and output a simple Wavefront .obj
   3 //                  file for the north, south, east, and west edge
   4 //                  verticies ... including the normals.
   5 //
   6 // Written by Curtis Olson, started January 1998.
   7 //
   8 // Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
   9 //
  10 // This program is free software; you can redistribute it and/or modify
  11 // it under the terms of the GNU General Public License as published by
  12 // the Free Software Foundation; either version 2 of the License, or
  13 // (at your option) any later version.
  14 //
  15 // This program is distributed in the hope that it will be useful,
  16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 // GNU General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU General Public License
  21 // along with this program; if not, write to the Free Software
  22 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 //
  24 // $Id$
  25 // (Log is kept at end of this file)
  26
  27
  28 #include <math.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>   // for atoi()
  31 #include <string.h>
  32 #include <sys/stat.h> // for stat()
  33 #include <unistd.h>   // for stat()
  34
  35 #include "splittris.hxx"
  36
  37 #include <Include/fg_constants.h>
  38 #include <Include/fg_types.h>
  39 #include <Bucket/bucketutils.h>
  40
  41 #include <Math/fg_geodesy.h>
  42 #include <Math/mat3.h>
  43 #include <Math/polar3d.hxx>
  44
  45 int nodecount, tricount;
  46 double xmin, xmax, ymin, ymax;
  47
  48 static double nodes_orig[MAX_NODES][3];
  49 static int tris[MAX_TRIS][3];
  50 // static int new_tris[MAX_TRIS][3];
  51
  52 static fgPoint3d nodes_cart[MAX_NODES];
  53
  54 fgBUCKET ne_index, nw_index, sw_index, se_index;
  55 fgBUCKET north_index, south_index, east_index, west_index;
  56
  57 // convert a geodetic point lon(arcsec), lat(arcsec), elev(meter) to a
  58 // cartesian point
  59 fgPoint3d geod_to_cart(double geod[3]) {
  60     fgPoint3d cp;
  61     fgPoint3d pp;
  62     double gc_lon, gc_lat, sl_radius;
  63
  64     // printf("A geodetic point is (%.2f, %.2f, %.2f)\n",
  65     //        geod[0], geod[1], geod[2]);
  66
  67     gc_lon = geod[0]*ARCSEC_TO_RAD;
  68     fgGeodToGeoc(geod[1]*ARCSEC_TO_RAD, geod[2], &sl_radius, &gc_lat);
  69
  70     // printf("A geocentric point is (%.2f, %.2f, %.2f)\n", gc_lon,
  71     //        gc_lat, sl_radius+geod[2]);
  72
  73     pp.lon = gc_lon;
  74     pp.lat = gc_lat;
  75     pp.radius = sl_radius + geod[2];
  76     cp = fgPolarToCart3d(pp);
  77
  78     // printf("A cart point is (%.8f, %.8f, %.8f)\n", cp.x, cp.y, cp.z);
  79
  80     return(cp);
  81 }
  82
  83
  84 // given three points defining a triangle, calculate the normal
  85 void calc_normal(fgPoint3d p1, fgPoint3d p2,
  86                  fgPoint3d p3, double normal[3])
  87 {
  88     double v1[3], v2[3];
  89     double temp;
  90
  91     v1[0] = p2.x - p1.x; v1[1] = p2.y - p1.y; v1[2] = p2.z - p1.z;
  92     v2[0] = p3.x - p1.x; v2[1] = p3.y - p1.y; v2[2] = p3.z - p1.z;
  93
  94     MAT3cross_product(normal, v1, v2);
  95     MAT3_NORMALIZE_VEC(normal,temp);
  96
  97     // printf("  Normal = %.2f %.2f %.2f\n", normal[0], normal[1], normal[2]);
  98 }
  99
 100
 101 // return the file base name ( foo/bar/file.ext = file.ext )
 102 void extract_file(char *in, char *base) {
 103     int len, i;
 104
 105     len = strlen(in);
 106
 107     i = len - 1;
 108     while ( (i >= 0) && (in[i] != '/') ) {
 109         i--;
 110     }
 111
 112     in += (i + 1);
 113     strcpy(base, in);
 114 }
 115
 116
 117 // return the file path name ( foo/bar/file.ext = foo/bar )
 118 void extract_path(char *in, char *base) {
 119     int len, i;
 120
 121     len = strlen(in);
 122     strcpy(base, in);
 123
 124     i = len - 1;
 125     while ( (i >= 0) && (in[i] != '/') ) {
 126         i--;
 127     }
 128
 129     base[i] = '\0';
 130 }
 131
 132
 133 // return the index of all triangles containing the specified node
 134 void find_tris(int n, int *t1, int *t2, int *t3, int *t4, int *t5) {
 135     int i;
 136
 137     *t1 = *t2 = *t3 = *t4 = *t5 = 0;
 138
 139     i = 1;
 140     while ( i <= tricount ) {
 141         if ( (n == tris[i][0]) || (n == tris[i][1]) || (n == tris[i][2]) ) {
 142             if ( *t1 == 0 ) {
 143                 *t1 = i;
 144             } else if ( *t2 == 0 ) {
 145                 *t2 = i;
 146             } else if ( *t3 == 0 ) {
 147                 *t3 = i;
 148             } else if ( *t4 == 0 ) {
 149                 *t4 = i;
 150             } else {
 151                 *t5 = i;
 152             }
 153         }
 154         i++;
 155     }
 156 }
 157
 158
 159 // Initialize a new mesh structure
 160 void triload(char *basename) {
 161     char nodename[256], elename[256];
 162     FILE *node, *ele;
 163     int dim, junk1, junk2;
 164     int i;
 165
 166     strcpy(nodename, basename);
 167     strcat(nodename, ".node");
 168     strcpy(elename, basename);
 169     strcat(elename, ".ele");
 170
 171     printf("Loading node file:  %s ...\n", nodename);
 172     if ( (node = fopen(nodename, "r")) == NULL ) {
 173         printf("Cannot open file '%s'\n", nodename);
 174         exit(-1);
 175     }
 176
 177     fscanf(node, "%d %d %d %d", &nodecount, &dim, &junk1, &junk2);
 178
 179     if ( nodecount > MAX_NODES - 1 ) {
 180         printf("Error, too many nodes, need to increase array size\n");
 181         exit(-1);
 182     } else {
 183         printf("    Expecting %d nodes\n", nodecount);
 184     }
 185
 186     for ( i = 1; i <= nodecount; i++ ) {
 187         fscanf(node, "%d %lf %lf %lf %d\n", &junk1,
 188                &nodes_orig[i][0], &nodes_orig[i][1], &nodes_orig[i][2], &junk2);
 189         // printf("%d %.2f %.2f %.2f\n", junk1, n[0], n[1], n[2]);
 190         nodes_cart[i] = geod_to_cart(nodes_orig[i]);
 191         // printf("%d %.2f %.2f %.2f\n",
 192         //        junk1, nodes_cart[i].x, nodes_cart[i].y, nodes_cart[i].z);
 193
 194         if ( i == 1 ) {
 195             xmin = xmax = nodes_orig[i][0];
 196             ymin = ymax = nodes_orig[i][1];
 197         } else {
 198             if ( nodes_orig[i][0] < xmin ) {
 199                 xmin = nodes_orig[i][0];
 200             }
 201             if ( nodes_orig[i][0] > xmax ) {
 202                 xmax = nodes_orig[i][0];
 203             }
 204             if ( nodes_orig[i][1] < ymin ) {
 205                 ymin = nodes_orig[i][1];
 206             }
 207             if ( nodes_orig[i][1] > ymax ) {
 208                 ymax = nodes_orig[i][1];
 209             }
 210         }
 211     }
 212
 213     fclose(node);
 214
 215     printf("Loading element file:  %s ...\n", elename);
 216     if ( (ele = fopen(elename, "r")) == NULL ) {
 217         printf("Cannot open file '%s'\n", elename);
 218         exit(-1);
 219     }
 220
 221     fscanf(ele, "%d %d %d", &tricount, &junk1, &junk2);
 222
 223     if ( tricount > MAX_TRIS - 1 ) {
 224         printf("Error, too many elements, need to increase array size\n");
 225         exit(-1);
 226     } else {
 227         printf("    Expecting %d elements\n", tricount);
 228     }
 229
 230     for ( i = 1; i <= tricount; i++ ) {
 231         fscanf(ele, "%d %d %d %d\n", &junk1,
 232                &tris[i][0], &tris[i][1], &tris[i][2]);
 233         // printf("%d %d %d %d\n", junk1, tris[i][0], tris[i][1], tris[i][2]);
 234     }
 235
 236     fclose(ele);
 237 }
 238
 239
 240 // check if a file exists
 241 int file_exists(char *file) {
 242     struct stat stat_buf;
 243     int result;
 244
 245     printf("checking %s ... ", file);
 246
 247     result = stat(file, &stat_buf);
 248
 249     if ( result != 0 ) {
 250         // stat failed, no file
 251         printf("not found.\n");
 252         return(0);
 253     } else {
 254         // stat succeeded, file exists
 255         printf("exists.\n");
 256         return(1);
 257     }
 258 }
 259
 260
 261 // check to see if a shared object exists
 262 int shared_object_exists(char *basepath, char *ext) {
 263     char file[256], scene_path[256];
 264     long int index;
 265
 266     if ( strcmp(ext, ".sw") == 0 ) {
 267         fgBucketGenBasePath(&west_index, scene_path);
 268         index = fgBucketGenIndex(&west_index);
 269         sprintf(file, "%s/%s/%ld.1.se", basepath, scene_path, index);
 270         if ( file_exists(file) ) {
 271             return(1);
 272         }
 273         fgBucketGenBasePath(&sw_index, scene_path);
 274         index = fgBucketGenIndex(&sw_index);
 275         sprintf(file, "%s/%s/%ld.1.ne", basepath, scene_path, index);
 276         if ( file_exists(file) ) {
 277             return(1);
 278         }
 279         fgBucketGenBasePath(&south_index, scene_path);
 280         index = fgBucketGenIndex(&south_index);
 281         sprintf(file, "%s/%s/%ld.1.nw", basepath, scene_path, index);
 282         if ( file_exists(file) ) {
 283             return(1);
 284         }
 285     }
 286
 287     if ( strcmp(ext, ".se") == 0 ) {
 288         fgBucketGenBasePath(&east_index, scene_path);
 289         index = fgBucketGenIndex(&east_index);
 290         sprintf(file, "%s/%s/%ld.1.sw", basepath, scene_path, index);
 291         if ( file_exists(file) ) {
 292             return(1);
 293         }
 294         fgBucketGenBasePath(&se_index, scene_path);
 295         index = fgBucketGenIndex(&se_index);
 296         sprintf(file, "%s/%s/%ld.1.nw", basepath, scene_path, index);
 297         if ( file_exists(file) ) {
 298             return(1);
 299         }
 300         fgBucketGenBasePath(&south_index, scene_path);
 301         index = fgBucketGenIndex(&south_index);
 302         sprintf(file, "%s/%s/%ld.1.ne", basepath, scene_path, index);
 303         if ( file_exists(file) ) {
 304             return(1);
 305         }
 306     }
 307
 308     if ( strcmp(ext, ".ne") == 0 ) {
 309         fgBucketGenBasePath(&east_index, scene_path);
 310         index = fgBucketGenIndex(&east_index);
 311         sprintf(file, "%s/%s/%ld.1.nw", basepath, scene_path, index);
 312         if ( file_exists(file) ) {
 313             return(1);
 314         }
 315         fgBucketGenBasePath(&ne_index, scene_path);
 316         index = fgBucketGenIndex(&ne_index);
 317         sprintf(file, "%s/%s/%ld.1.sw", basepath, scene_path, index);
 318         if ( file_exists(file) ) {
 319             return(1);
 320         }
 321         fgBucketGenBasePath(&north_index, scene_path);
 322         index = fgBucketGenIndex(&north_index);
 323         sprintf(file, "%s/%s/%ld.1.se", basepath, scene_path, index);
 324         if ( file_exists(file) ) {
 325             return(1);
 326         }
 327     }
 328
 329     if ( strcmp(ext, ".nw") == 0 ) {
 330         fgBucketGenBasePath(&west_index, scene_path);
 331         index = fgBucketGenIndex(&west_index);
 332         sprintf(file, "%s/%s/%ld.1.ne", basepath, scene_path, index);
 333         if ( file_exists(file) ) {
 334             return(1);
 335         }
 336         fgBucketGenBasePath(&nw_index, scene_path);
 337         index = fgBucketGenIndex(&nw_index);
 338         sprintf(file, "%s/%s/%ld.1.se", basepath, scene_path, index);
 339         if ( file_exists(file) ) {
 340             return(1);
 341         }
 342         fgBucketGenBasePath(&north_index, scene_path);
 343         index = fgBucketGenIndex(&north_index);
 344         sprintf(file, "%s/%s/%ld.1.sw", basepath, scene_path, index);
 345         if ( file_exists(file) ) {
 346             return(1);
 347         }
 348     }
 349
 350     if ( strcmp(ext, ".south") == 0 ) {
 351         fgBucketGenBasePath(&south_index, scene_path);
 352         index = fgBucketGenIndex(&south_index);
 353         sprintf(file, "%s/%s/%ld.1.north", basepath, scene_path, index);
 354         if ( file_exists(file) ) {
 355             return(1);
 356         }
 357     }
 358
 359     if ( strcmp(ext, ".north") == 0 ) {
 360         fgBucketGenBasePath(&north_index, scene_path);
 361         index = fgBucketGenIndex(&north_index);
 362         sprintf(file, "%s/%s/%ld.1.south", basepath, scene_path, index);
 363         if ( file_exists(file) ) {
 364             return(1);
 365         }
 366     }
 367
 368     if ( strcmp(ext, ".west") == 0 ) {
 369         fgBucketGenBasePath(&west_index, scene_path);
 370         index = fgBucketGenIndex(&west_index);
 371         sprintf(file, "%s/%s/%ld.1.east", basepath, scene_path, index);
 372         if ( file_exists(file) ) {
 373             return(1);
 374         }
 375     }
 376
 377     if ( strcmp(ext, ".east") == 0 ) {
 378         fgBucketGenBasePath(&east_index, scene_path);
 379         index = fgBucketGenIndex(&east_index);
 380         sprintf(file, "%s/%s/%ld.1.west", basepath, scene_path, index);
 381         if ( file_exists(file) ) {
 382             return(1);
 383         }
 384     }
 385
 386     return(0);
 387 }
 388
 389
 390 // my custom file opening routine ... don't open if a shared edge or
 391 // vertex alread exists
 392 FILE *my_open(char *basename, char *basepath, char *ext) {
 393     FILE *fp;
 394     char filename[256];
 395
 396     // create the output file name
 397     strcpy(filename, basename);
 398     strcat(filename, ext);
 399
 400     // check if a shared object already exist from a different tile
 401
 402     if ( shared_object_exists(basepath, ext) ) {
 403         // not an actual file open error, but we've already got the
 404         // shared edge, so we don't want to create another one
 405         printf("not opening\n");
 406         return(NULL);
 407     } else {
 408         // open the file
 409         fp = fopen(filename, "w");
 410         printf("Opening %s\n", filename);
 411         return(fp);
 412     }
 413 }
 414
 415
 416 // dump in WaveFront .obj format
 417 void dump_obj(char *basename, char *basepath) {
 418     double n1[3], n2[3], n3[3], n4[3], n5[3], norm[3], temp;
 419     FILE *fp, *sw, *se, *ne, *nw, *north, *south, *east, *west, *body;
 420     int i, t1, t2, t3, t4, t5, count;
 421
 422     sw = my_open(basename, basepath, ".sw");
 423     se = my_open(basename, basepath, ".se");
 424     ne = my_open(basename, basepath, ".ne");
 425     nw = my_open(basename, basepath, ".nw");
 426
 427     north = my_open(basename, basepath, ".north");
 428     south = my_open(basename, basepath, ".south");
 429     east = my_open(basename, basepath, ".east");
 430     west = my_open(basename, basepath, ".west");
 431
 432     body = my_open(basename, basepath, ".body");
 433
 434     printf("Dumping edges file basename:  %s ...\n", basename);
 435
 436     // dump vertices
 437     printf("  writing vertices\n");
 438     for ( i = 1; i <= nodecount; i++ ) {
 439
 440         if ( (fabs(nodes_orig[i][1] - ymin) < FG_EPSILON) &&
 441              (fabs(nodes_orig[i][0] - xmin) < FG_EPSILON) ) {
 442             fp = sw;
 443         } else if ( (fabs(nodes_orig[i][1] - ymin) < FG_EPSILON) &&
 444                     (fabs(nodes_orig[i][0] - xmax) < FG_EPSILON) ) {
 445             fp = se;
 446         } else if ( (fabs(nodes_orig[i][1] - ymax) < FG_EPSILON) &&
 447                     (fabs(nodes_orig[i][0] - xmax) < FG_EPSILON)) {
 448             fp = ne;
 449         } else if ( (fabs(nodes_orig[i][1] - ymax) < FG_EPSILON) &&
 450                     (fabs(nodes_orig[i][0] - xmin) < FG_EPSILON) ) {
 451             fp = nw;
 452         } else if ( fabs(nodes_orig[i][0] - xmin) < FG_EPSILON ) {
 453             fp = west;
 454         } else if ( fabs(nodes_orig[i][0] - xmax) < FG_EPSILON ) {
 455             fp = east;
 456         } else if ( fabs(nodes_orig[i][1] - ymin) < FG_EPSILON ) {
 457             fp = south;
 458         } else if ( fabs(nodes_orig[i][1] - ymax) < FG_EPSILON ) {
 459             fp = north;
 460         } else {
 461             fp = body;
 462         }
 463
 464         if ( fp != NULL ) {
 465             fprintf(fp, "gdn %.2f %.2f %.2f\n",
 466                     nodes_orig[i][0], nodes_orig[i][1], nodes_orig[i][2]);
 467         }
 468     }
 469
 470     printf("  calculating and writing normals\n");
 471     // calculate and generate normals
 472     for ( i = 1; i <= nodecount; i++ ) {
 473         // printf("Finding normal\n");
 474
 475         find_tris(i, &t1, &t2, &t3, &t4, &t5);
 476
 477         n1[0] = n1[1] = n1[2] = 0.0;
 478         n2[0] = n2[1] = n2[2] = 0.0;
 479         n3[0] = n3[1] = n3[2] = 0.0;
 480         n4[0] = n4[1] = n4[2] = 0.0;
 481         n5[0] = n5[1] = n5[2] = 0.0;
 482
 483         count = 1;
 484         calc_normal(nodes_cart[tris[t1][0]], nodes_cart[tris[t1][1]],
 485                     nodes_cart[tris[t1][2]], n1);
 486
 487         if ( t2 > 0 ) {
 488             calc_normal(nodes_cart[tris[t2][0]], nodes_cart[tris[t2][1]],
 489                         nodes_cart[tris[t2][2]], n2);
 490             count = 2;
 491         }
 492
 493         if ( t3 > 0 ) {
 494             calc_normal(nodes_cart[tris[t3][0]], nodes_cart[tris[t3][1]],
 495                         nodes_cart[tris[t3][2]], n3);
 496             count = 3;
 497         }
 498
 499         if ( t4 > 0 ) {
 500             calc_normal(nodes_cart[tris[t4][0]], nodes_cart[tris[t4][1]],
 501                         nodes_cart[tris[t4][2]], n4);
 502             count = 4;
 503         }
 504
 505         if ( t5 > 0 ) {
 506             calc_normal(nodes_cart[tris[t5][0]], nodes_cart[tris[t5][1]],
 507                         nodes_cart[tris[t5][2]], n5);
 508             count = 5;
 509         }
 510
 511         // printf("  norm[2] = %.2f %.2f %.2f\n", n1[2], n2[2], n3[2]);
 512
 513         norm[0] = ( n1[0] + n2[0] + n3[0] + n4[0] + n5[0] ) / (double)count;
 514         norm[1] = ( n1[1] + n2[1] + n3[1] + n4[1] + n5[1] ) / (double)count;
 515         norm[2] = ( n1[2] + n2[2] + n3[2] + n4[2] + n5[2] ) / (double)count;
 516
 517         // printf("  count = %d\n", count);
 518         // printf("  Ave. normal = %.4f %.4f %.4f\n", norm[0], norm[1],
 519         //        norm[2]);
 520         MAT3_NORMALIZE_VEC(norm, temp);
 521         // printf("  Normalized ave. normal = %.4f %.4f %.4f\n",
 522         //        norm[0], norm[1], norm[2]);
 523
 524         fp = NULL;
 525
 526         if ( (fabs(nodes_orig[i][1] - ymin) < FG_EPSILON) &&
 527              (fabs(nodes_orig[i][0] - xmin) < FG_EPSILON) ) {
 528             fp = sw;
 529         } else if ( (fabs(nodes_orig[i][1] - ymin) < FG_EPSILON) &&
 530                     (fabs(nodes_orig[i][0] - xmax) < FG_EPSILON) ) {
 531             fp = se;
 532         } else if ( (fabs(nodes_orig[i][1] - ymax) < FG_EPSILON) &&
 533                     (fabs(nodes_orig[i][0] - xmax) < FG_EPSILON)) {
 534             fp = ne;
 535         } else if ( (fabs(nodes_orig[i][1] - ymax) < FG_EPSILON) &&
 536                     (fabs(nodes_orig[i][0] - xmin) < FG_EPSILON) ) {
 537             fp = nw;
 538         } else if ( fabs(nodes_orig[i][0] - xmin) < FG_EPSILON ) {
 539             fp = west;
 540         } else if ( fabs(nodes_orig[i][0] - xmax) < FG_EPSILON ) {
 541             fp = east;
 542         } else if ( fabs(nodes_orig[i][1] - ymin) < FG_EPSILON ) {
 543             fp = south;
 544         } else if ( fabs(nodes_orig[i][1] - ymax) < FG_EPSILON ) {
 545             fp = north;
 546         }
 547         if ( fp != NULL ) {
 548             fprintf(fp, "vn %.4f %.4f %.4f\n", norm[0], norm[1], norm[2]);
 549         }
 550     }
 551
 552     if ( sw ) { fclose(sw); }
 553     if ( se ) { fclose(se); }
 554     if ( ne ) { fclose(ne); }
 555     if ( nw ) { fclose(nw); }
 556
 557     if ( north ) { fclose(north); }
 558     if ( south ) { fclose(south); }
 559     if ( east ) { fclose(east); }
 560     if ( west ) { fclose(west); }
 561
 562     if ( body ) { fclose(body); }
 563 }
 564
 565
 566 int main(int argc, char **argv) {
 567     char basename[256], basepath[256], temp[256];
 568     fgBUCKET p;
 569     long int index;
 570     int len;
 571
 572     strcpy(basename, argv[1]);
 573
 574     // find the base path of the file
 575     extract_path(basename, basepath);
 576     extract_path(basepath, basepath);
 577     extract_path(basepath, basepath);
 578     printf("%s\n", basepath);
 579
 580     // find the index of the current file
 581     extract_file(basename, temp);
 582     len = strlen(temp);
 583     if ( len >= 2 ) {
 584         temp[len-2] = '\0';
 585     }
 586     index = atoi(temp);
 587     printf("%ld\n", index);
 588     fgBucketParseIndex(index, &p);
 589
 590     printf("bucket = %d %d %d %d\n", p.lon, p.lat, p.x, p.y);
 591     // generate the indexes of the neighbors
 592     fgBucketOffset(&p, &ne_index,  1,  1);
 593     fgBucketOffset(&p, &nw_index, -1,  1);
 594     fgBucketOffset(&p, &se_index,  1, -1);
 595     fgBucketOffset(&p, &sw_index, -1, -1);
 596
 597     fgBucketOffset(&p, &north_index,  0,  1);
 598     fgBucketOffset(&p, &south_index,  0, -1);
 599     fgBucketOffset(&p, &east_index,  1,  0);
 600     fgBucketOffset(&p, &west_index, -1,  0);
 601
 602     // printf("Corner indexes = %ld %ld %ld %ld\n",
 603     //        ne_index, nw_index, sw_index, se_index);
 604     // printf("Edge indexes = %ld %ld %ld %ld\n",
 605     //        north_index, south_index, east_index, west_index);
 606
 607
 608     // load the input data files
 609     triload(basename);
 610
 611     // dump in WaveFront .obj format
 612     dump_obj(basename, basepath);
 613
 614     return(0);
 615 }
 616
 617
 618 // $Log$
 619 // Revision 1.2  1998/09/21 23:16:23  curt
 620 // Converted to c++ style comments.
 621 //
 622 // Revision 1.1  1998/07/08 14:59:13  curt
 623 // *.[ch] renamed to *.[ch]xx
 624 //
 625 // Revision 1.11  1998/07/04 00:56:40  curt
 626 // typedef'd struct fgBUCKET.
 627 //
 628 // Revision 1.10  1998/05/02 01:54:37  curt
 629 // Converting to polar3d.h routines.
 630 //
 631 // Revision 1.9  1998/04/18 04:01:20  curt
 632 // Now use libMath rather than having local copies of math routines.
 633 //
 634 // Revision 1.8  1998/04/14 02:26:08  curt
 635 // Code reorganizations.  Added a Lib/ directory for more general libraries.
 636 //
 637 // Revision 1.7  1998/04/08 23:21:13  curt
 638 // Adopted Gnu automake/autoconf system.
 639 //
 640 // Revision 1.6  1998/03/03 15:36:13  curt
 641 // Tweaks for compiling with g++
 642 //
 643 // Revision 1.5  1998/03/03 03:37:04  curt
 644 // Cumulative tweaks.
 645 //
 646 // Revision 1.4  1998/01/31 00:41:26  curt
 647 // Made a few changes converting floats to doubles.
 648 //
 649 // Revision 1.3  1998/01/27 18:37:04  curt
 650 // Lots of updates to get back in sync with changes made over in .../Src/
 651 //
 652 // Revision 1.2  1998/01/14 15:54:43  curt
 653 // Initial revision completed.
 654 //
 655 // Revision 1.1  1998/01/14 02:11:31  curt
 656 // Initial revision.
 657 //
 658