static char rcsid[] = "$Id: ciamap.c,v 3.10 1993/01/05 01:37:03 putz Exp $";
/*****************************************************************************
* ciamap.c - This program reads a map database file in the CIA World Base
*      format and produces a netmap-format output file.
*
* Originally created by Brian Reid ([email protected])
* Modified March 1991 by Steve Putz ([email protected])
*****************************************************************************/

#include <stdio.h>
#include <math.h>
#include <ctype.h>
#include <strings.h>
#include <sys/file.h>
#include <sys/param.h>          /* for MAXPATHLEN */
#include "cbdmap.h"

#define BIT32   int             /* change these definitions to suit your */
#define BIT16   short           /* own machine                           */
#define BIT8    char
#define TRUE    1
#define FALSE   0
/*
* The data-compression scheme uses integer seconds to represent lat/long,
* and stores each stroke as a [dx,dy] from the previous point. If dy will
* fit into 8 bits and dx into 7 bits, then the entire [dx,dy] is stored in a
* 16-bit field with bit 0x4000 turned on as a flag. If either value is too
* large for that scheme, then both are stored as 32-bit values, with the
* 0x40000000 bit turned off (even in negative numbers) in the first of them.
*/

#define MAXSEG  20000           /* maximum strokes in a segment */
#define MAXSEGS 10000

#define abs(x)  (x<0 ? -(x) : x)
#define sign(x) ((x>=0) ? 1 : -1)

struct seghead  sb;

BIT16           segbuf[MAXSEG];

struct segdict  sd[MAXSEGS];
static long     acodes[MAXSEGS];
static long     acodeCounts[MAXSEGS];
static char     CodeTable[100];

int             MapDetail = 99;

int             rightShift = 0;
int             filterBits = 0;
int             paethFlag = 0;
int             inrec_bytes = 0;
int             debug = 0;

#define PUTSHORT(val, file) { putc((val)>>8, file); putc((val)&0xFF, file); }
#define PUTCOORD(seconds, file) PUTSHORT((seconds)/20, file)

/* ------------------------------------------------------------------------ */

main(argc, argv)
   int             argc;
   char          **argv;
{
   extern int      optind;
   extern char    *optarg;
   extern char    *strcpy();
   int             c, initdone, badopts;
   char            *outdir = NULL, *outfname = NULL;

   for (c = 0; c < 100; c++) CodeTable[c] = c;

   initdone = 0;
   badopts = 0;
   while ((c = getopt(argc, argv, "D:d:pn:s:f:t:T:O:o:m")) != EOF)
       switch (c) {
       case 'D':
           /* -D: debug. Argument is an integer debuging flags mask. */
           debug = strtol(optarg, NULL, 0);
           break;
       case 'd':
           /*
            * -d: detail. Argument is an integer giving map detail to
            * include.
            */
           sscanf(optarg, "%d", &MapDetail);
           break;
       case 'p':
           /* -p: Paeth format. Produce Paeth format map files.  */
           paethFlag = TRUE;
           break;
       case 'n':
           /*
            * -n: no newline chars in input. Argument is bytes/record.
            */
           sscanf(optarg, "%d", &inrec_bytes);
           break;
       case 's':
           /*
            * -s: Scale data. Argument is number of bits to right shift
            * coordinate data.
            */
           sscanf(optarg, "%d", &rightShift);
           break;
       case 'f':
           /* -f: Filter data. Argument is number of bits to smooth. */
           sscanf(optarg, "%d", &filterBits);
           break;
       case 't':
           /* -t: translate codes. Argument is feature code file name. */
           ReadCodes(optarg, CodeTable);
           break;
       case 'T':
           /* -T: translate codes. warn of features not in code file. */
           for (c = 0; c < 100; c++) CodeTable[c] = -1;
           ReadCodes(optarg, CodeTable);
           break;
       case 'O':
           /* -O: specify output directory */
           outdir = optarg;
           break;
       case 'o':
           /* -o: specify output file */
           outfname = optarg;
           break;
       case 'm':
           /* -m: Ascii map files follow. "-m f2 f2 f3" */
           for (; optind < argc && argv[optind][0] != '-'; optind++) {
               if (!initdone);
               initdone++;
               TranslateMap(argv[optind], outdir, outfname);
           }
           break;
       default:
           badopts++;
       }
   fflush(stdout);
   if (badopts) {
       exit(2);
   }
}


/* ------------------------------------------------------------------------ */

ReadCodes(name, codetable)
   char           *name;
   char        *codetable;
{
   FILE *df;
   int code1, code2, res;
   char desc[100];

   if (!(df = fopen(name, "r"))) {
       perror(name);
       exit(1);
   }
   while (!feof(df)) {
       *desc = '\0';
       res = fscanf(df, "%d %d %[^\n]\n", &code1, &code2, desc);
       if (res < 2) {
           fscanf(df, "%[^\n]\n", desc);
           if (debug & 0x1000)
               fprintf(stdout, "%s\n", desc);
       } else {
           if (debug & 0x2000)
               fprintf(stdout, "%d -> %d %s\n", code1, code2, desc);
           codetable[code1%100] = code2;
       }
   }

   fclose(df);

} /* ReadCodes */


/* ------------------------------------------------------------------------ */

TranslateMap(name, outdir, outfname)
   char           *name, *outdir, *outfname;
{
   FILE           *df;
   char            line[100], of[MAXPATHLEN], *bname, *ext,
                   lad,        /* 'N' or 'S' */
                   lod;        /* 'E' or 'W' */
   int             Ofile = -1, first, lsn, irnk, nop, ladg, lam, las,
                   lodg, lom, los,
                   ipn,        /* polygon number */
                   acode, acount,
                   big = 0, small = 0, medium = 0, skippedSegs = 0,
                   totalStrokes = 0, skippedStrokes = 0, lnum, nc,
                   i, j, strokecount, segmax, segsize, segcount, bytecount;
   BIT32           jlat,       /* integer latitude in seconds */
                   jlong,      /* integer longitude in seconds */
                   haveLat = 0, haveLong = 0, dx, dy;
   struct cbdhead  header;
   FILE           *paethIndex = NULL, *paethData = NULL;
   int             paethCount, paethTotal = 0;
   int             headerSize = CBD_HEADSIZE2;
   long            roundBit = 1 << (rightShift - 1);

   if (!(df = fopen(name, "r"))) {
       perror(name);
       exit(1);
   }
   bname = rindex(name, '/');
   if (bname) bname++;
   else bname = name;

   if (outdir) sprintf(of, "%s/", outdir);
   else *of = '\0';

   if (outfname) strcat(of, outfname);
   else strcat(of, bname);

   ext = index(of, '.');
   if (ext)
       *ext = '\0';
   else
       ext = of + strlen(of);

   if (paethFlag) {
       strcpy(ext, ".index");
       paethIndex = fopen(of, "w");
       strcpy(ext, ".map");
       paethData = fopen(of, "w");
       if (paethIndex == NULL || paethData == NULL) {
           perror(of);
           exit(1);
       }
   } else {
       if (!outfname) {
           if (rightShift) {
               sprintf(ext, "%+d", -rightShift);
               ext += strlen(ext);
           }
           if (filterBits) {
               sprintf(ext, "f%d", filterBits);
               ext += strlen(ext);
           }
           strcpy(ext, ".cbd");
       }
       Ofile = open(of, O_RDWR | O_CREAT | O_TRUNC, 0666);
       if (Ofile < 0) {
           perror(of);
           exit(1);
       }
   }

   fprintf(stdout, "Reading %s\nWriting %s\n", name, of);

   bzero(&header, sizeof(header));
   /* note that header.magic is zero until we are done */
   header.scale_shift = -rightShift;
   header.minlat = DEG90_SECS;
   header.maxlat = -DEG90_SECS;
   header.minlong = DEG180_SECS;
   header.maxlong = -DEG180_SECS;

   if (Ofile >= 0) {           /* reserve space for header */
       write(Ofile, &header, headerSize);
   }
   acount = 0;
   segcount = 0;
   segmax = 0;
   line[inrec_bytes] = '\0';

   /* The header line tells us  the serial number, rank, and path size */
   lnum = 0;
   for (;;) {
       if (inrec_bytes) {
           if (fread(line, inrec_bytes, 1, df) != 1) break;
       } else {
           if (fgets(line, 60, df) == NULL) break;
       }
       lnum++;
       for (nc = 0; nc < 20 && line[nc] != NULL; nc++)
          if (line[nc] == ' ') line[nc] = '0';

       if (nc < 18)
           continue;

       sscanf(line, "%7d%2d%6d%5d", &lsn, &irnk, &nop, &acode);
       if (debug & 0x100)
           fprintf(stdout, "%d: ID=%d, rank=%d, NP=%d, code=%d\n",
               segcount, lsn, irnk, nop, acode);
       acode = acode * 100 + irnk;
       if (CodeTable[irnk] > 32 || CodeTable[irnk] < 1) {
           fprintf(stdout, "WARNING: file %s, seg %d: ID=%d, rank=%d, NP=%d, code=%d -> %d\n",
               name, segcount, lsn, irnk, nop, acode, CodeTable[irnk]);
           irnk = 32;
       } else {
           irnk = CodeTable[irnk];
       }

       if (irnk > MapDetail) {
           for (i = 1; i <= nop; i++) {
               if (inrec_bytes) {
                   if (fread(line, inrec_bytes, 1, df) != 1) break;
               } else {
                   if (fgets(line, 60, df) == NULL) break;
               }
               lnum++;
           }
       } else {
           sb.id = lsn;
           first = FALSE;
           if (segcount > MAXSEGS) {
               fprintf(stdout, "Segment count overflow.\n");
               close(Ofile);
               fclose(df);
               return;
           }
           if (Ofile >= 0)
               sd[segcount].absaddr = tell(Ofile);
           sd[segcount].segid = lsn;
           sd[segcount].rank = irnk;

           sd[segcount].minlat = DEG90_SECS;
           sd[segcount].maxlat = -DEG90_SECS;
           sd[segcount].minlong = DEG180_SECS;
           sd[segcount].maxlong = -DEG180_SECS;

           {   int found = 0;
               for (i = 0; i < acount; i++) {
                   if (acodes[i] == acode) {
                       acodeCounts[i]++;
                       found = 1;
                       break;
                   }
               }
               if (!found) {
                   acodeCounts[acount] = 1;
                   acodes[acount++] = acode;
                   if (debug & 0x800)
                       fprintf(stdout, "code %d\n", acode);
               }
           }

           bytecount = 0;
           segsize = 0;
           paethCount = 0;
           for (i = 1; i <= nop; i++) {
               if (inrec_bytes) {
                   if (fread(line, inrec_bytes, 1, df) != 1) break;
               } else {
                   if (fgets(line, 60, df) == NULL) break;
               }
               lnum++;
               for (j = 0; j <= 19; j++) {
                   if (line[j] == ' ')
                       line[j] = '0';
               }
#define DIG(x) ((int)(x)-48)
               ladg = 10 * DIG(line[0]) + DIG(line[1]);
               lam = 10 * DIG(line[2]) + DIG(line[3]);
               las = 10 * DIG(line[4]) + DIG(line[5]);
               lad = line[6];
               lodg = 100 * DIG(line[7]) + 10 * DIG(line[8]) + DIG(line[9]);
               lom = 10 * DIG(line[10]) + DIG(line[11]);
               los = 10 * DIG(line[12]) + DIG(line[13]);
               lod = line[14];
               ipn = 1000 * DIG(line[16]) + 100 * DIG(line[17]) + 10 *
                       DIG(line[18]) + DIG(line[19]);

               if (debug & 0x200)
                   fprintf(stdout, "%d: %02d %02d %02d %c %03d %02d %02d %c %05d\n",
                       segcount, ladg, lam, las, lad, lodg, lom, los, lod, ipn);

               if (ipn != i) {
                   fprintf(stdout, "Data error at line %d, sequence %d, segment %d: expected %d but found: %d\n%s\n",
                       lnum, lsn, segcount, i, ipn, line);
                   if (ipn > 0 && ipn < nop)
                       i = ipn;
               }
               jlat = 3600 * ladg + 60 * lam + las;
               if (lad == 'S')
                   jlat = -jlat;
               jlong = 3600 * lodg + 60 * lom + los;
               if (lod == 'W')
                   jlong = -jlong;
               if (debug & 0x04)
                   fprintf(stdout, "(%.4f %.4f) = (%d %d) [%x %x]",
                    jlong / 3600.0, jlat / 3600.0, jlong, jlat, jlong, jlat);
               if (rightShift > 0) {
                   if (jlong & roundBit) {
                       jlong = (jlong >> rightShift) + 1;
                       if (debug & 0x20) fprintf(stdout, " x%+1 ");
                   } else {
                       jlong >>= rightShift;
                   }
                   if (jlat & roundBit) {
                       jlat = (jlat >> rightShift) + 1;
                       if (debug & 0x20) fprintf(stdout, " y%+1 ");
                   } else {
                       jlat >>= rightShift;
                   }
                   if (debug & 0x10)
                       fprintf(stdout, "-> (%d %d) [%x %x]", jlong, jlat, jlong, jlat);
               }
               if (debug & 0x04)
                   fprintf(stdout, "\n");
               if (sd[segcount].maxlat < jlat)
                   sd[segcount].maxlat = jlat;
               if (sd[segcount].minlat > jlat)
                   sd[segcount].minlat = jlat;
               if (sd[segcount].maxlong < jlong)
                   sd[segcount].maxlong = jlong;
               if (sd[segcount].minlong > jlong)
                   sd[segcount].minlong = jlong;
               if (!first) {
                   first = TRUE;
                   sb.orgx = jlong;
                   sb.orgy = jlat;
                   strokecount = 0;
               } else {
                   dx = jlong - haveLong;
                   dy = jlat - haveLat;
                   if (dx == 0 && dy == 0 ||
                               i < nop && abs(dx) + abs(dy) <= filterBits) {
                       skippedStrokes++;
                       if (debug & 0x02)
                           fprintf(stdout, "skipped: (%d %d)\n", dx, dy);
                       continue;       /* don't set haveLat, haveLong */
                   } else {
                       totalStrokes++;
                       strokecount++;
                       if (abs(dx) > MAX8x || abs(dy) > MAX8y) {
                           /*
                            * Encode this transition as a pair of 32-bit
                            * values.
                            */
                           big++;
                           if (abs(dx) <= 0x3FFF && abs(dy) <= 0x7FFF)
                               medium++;
                           bytecount += 8;
                           if (segsize + 4 > MAXSEG) {
                               fprintf(stdout, "segsize overflow.\n");
                               close(Ofile);
                               fclose(df);
                               return;
                           }
                           segbuf[segsize++] = (dx >> 16) & ~SHORTFLAG;
                           segbuf[segsize++] = dx & 0xFFFF;
                           segbuf[segsize++] = (dy >> 16);
                           segbuf[segsize++] = dy & 0xFFFF;
                           if (debug & 0x02)
                               fprintf(stdout, "%4d: long (%d %d): %04x %04x %04x %04x\n", strokecount, dx, dy, segbuf[segsize - 4] & 0xFFFF, segbuf[segsize - 3] & 0xFFFF, segbuf[segsize - 2] & 0xFFFF, segbuf[segsize - 1] & 0xFFFF);
                       } else {
                           /*
                            * Encode this transition as a pair of 8-bit
                            * values.
                            */
                           small++;
                           bytecount += 2;
                           if (segsize + 1 > MAXSEG) {
                               fprintf(stdout, "segsize overflow.\n");
                               close(Ofile);
                               fclose(df);
                               return;
                           }
                           segbuf[segsize++] =
                               SHORTFLAG |
                               (dx << 8) |
                               (dy & 0xFF);
                           if (debug & 0x02)
                               fprintf(stdout, "%4d: short (%d %d): %04x\n", strokecount, dx, dy, segbuf[segsize - 1] & 0xFFFF);
                       }       /* short encoding */
                       if (paethFlag) {
                           PUTCOORD(jlat, paethData);
                           PUTCOORD(jlong, paethData);
                           paethCount++;
                       }
                   }           /* dx,dy != 0 */
               }               /* not first */
               haveLat = jlat;
               haveLong = jlong;
           }

           if (strokecount == 0) {
               skippedSegs++;  /* reuse same segment */
           } else if (Ofile >= 0) {
               sd[segcount].nbytes = bytecount;
               sb.nstrokes = strokecount;
               write(Ofile, &sb, sizeof sb);
               write(Ofile, segbuf, bytecount);
               if (debug & 0x01)
                   fprintf(stdout, "seg %d: (%.4f %.4f)=(%d %d) %d strokes %d bytes, code %03d %04d\n", sb.id, (sb.orgx << rightShift) / 3600.0, (sb.orgy << rightShift) / 3600.0, sb.orgx, sb.orgy, sb.nstrokes, bytecount, acode/10000, acode % 10000);
               if (debug & 0x0400)
                   fprintf(stdout, "seg NSEW = (%.4f %.4f %.4f %.4f)\n",
                           (sd[segcount].maxlat << rightShift) / 3600.0,
                           (sd[segcount].minlat << rightShift) / 3600.0,
                           (sd[segcount].maxlong << rightShift) / 3600.0,
                           (sd[segcount].minlong << rightShift) / 3600.0);
               header.features |= (1 << (sd[segcount].rank - 1));
               if (header.maxlat < sd[segcount].maxlat)
                   header.maxlat = sd[segcount].maxlat;
               if (header.minlat > sd[segcount].minlat)
                   header.minlat = sd[segcount].maxlat;
               if (header.maxlong < sd[segcount].maxlong)
                   header.maxlong = sd[segcount].maxlong;
               if (header.minlong > sd[segcount].minlong)
                   header.minlong = sd[segcount].minlong;
               segcount++;
           } else if (paethFlag) {
               PUTCOORD(sd[segcount].maxlat, paethIndex);
               PUTCOORD(sd[segcount].minlat, paethIndex);
               PUTCOORD(sd[segcount].maxlong, paethIndex);
               PUTCOORD(sd[segcount].minlong, paethIndex);
               PUTSHORT(paethCount, paethIndex);
               paethTotal += paethCount;
           }
       }
       /* end of each segment */

       if (segsize > segmax)
           segmax = segsize;
   }
   /* end of file */
   header.magic = headerSize == CBD_HEADSIZE2 ? CBD_MAGIC2 : CBD_MAGIC;
   header.dictaddr = tell(Ofile);
   header.segcount = segcount;
   header.segsize = segcount * sizeof(struct segdict);
   header.segmax = segmax;

   fprintf(stdout,
           "Segdict has %d entries (%d skipped), %d bytes, starts at %d.\n\
       %d strokes (%d skipped)\n\
       Largest segment has %d entries (%d bytes)\n\
       %d small entries, %d big (%.2f%% of space), %d medium\n",
           segcount, skippedSegs, header.segsize, header.dictaddr,
           totalStrokes, skippedStrokes,
           segmax, 2 * segmax,
           small, big, (double) 100 * big * 4 / (big * 4 + small), medium);
   {   int i;
       fprintf(stdout, "features:");
       for (i = 1; i <= 32; i++)
           if (header.features & (1<<(i-1))) fprintf(stdout, " %d", i);
       fprintf(stdout, "\n");
       fprintf(stdout, "%d codes:\n", acount);
       for (i = 0; i < acount; i++)
           fprintf(stdout, "code %07d %5d\n", acodes[i], acodeCounts[i]);
   }
   if (paethFlag) {
       fprintf(stdout, "\t%d paeth points\n", paethTotal);
       fclose(paethData);
       fclose(paethIndex);
   } else {
       write(Ofile, sd, (int) header.segsize);
       lseek(Ofile, 0L, L_SET);
       write(Ofile, &header, headerSize);
       close(Ofile);
   }
   fclose(df);
}

You are viewing proxied material from infinitelyremote.com. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.