----------------------------------------------
json2glyph_in.c
----------------------------------------------
/**
 **   json2glyph_in - custom code to convert Logos json to glyph_factory inputs
 ** 
 **  CREATED:  2014.08.10  ABS  copied from t_filter
 ** MODIFIED:  2014.08.11  ABS  got working
 ** MODIFIED:  2014.08.12  ABS  enhanced
 ** MODIFIED:  2014.10.01  ABS  removed non Sensorname input
 **
 **/

#include        "json2glyph_in.h"

main(argc, argv)
int argc;
char** argv;
{
    /* declare functions */

    double atof();
    void strip_char();

    /* declare local variables */

    int c, i, lim, cb, sb, coord_count, new_coord_count, cc, ncc, m;
    int dn, ndn; /* data as number, new data as number */
    int row, r2, denom, timecode;

    int red[400], grn[400], blu[400];

    char temp_buffer[4096];
    char h1[512];
    char d1[512];
    char h2[512];
    char d2[512];

    char tags_file[512];
    char link_file[512];

    FILE *tags_fp;
    FILE *link_fp;

    /*******************
    char lat[8192][512];
    char lon[8192][512];
    *******************/

    char **lat;
    char **lon;
    char **new_lat;
    char **new_lon;

    lat = (char**)malloc(8192*sizeof(char*));
    for (m = 0; m < 8192; m++) {
        lat[m] = (char*) malloc(512*sizeof(char));
        } 

    lon = (char**)malloc(8192*sizeof(char*));
    for (m = 0; m < 8192; m++) {
        lon[m] = (char*) malloc(512*sizeof(char));
        } 

    new_lat = (char**)malloc(8192*sizeof(char*));
    for (m = 0; m < 8192; m++) {
        new_lat[m] = (char*) malloc(512*sizeof(char));
        } 

    new_lon = (char**)malloc(8192*sizeof(char*));
    for (m = 0; m < 8192; m++) {
        new_lon[m] = (char*) malloc(512*sizeof(char));
        } 

    /* initialize global variables (including parameters) */

    defaultParms();
    parseArgs(argc, argv);

    if (Debug != FALSE) {
        fprintf(stderr, "%s: DEBUG: Debug = %d\n", argv[0], Debug);
        fprintf(stderr, "%s: DEBUG: Base  = %d\n", argv[0], Base);
        fprintf(stderr, "%s: DEBUG: Size  = %f\n", argv[0], Size);
        }

    /* initialize local variables */

    strcpy(tags_file, "tags_template.txt");
    strcpy(link_file, "links.txt");

    red[0]  = 255; grn[0]  = 128; blu[0]  =   0; /* believed unused */
    red[1]  =   0; grn[1]  =   0; blu[1]  = 255; /* confirmed */
    red[2]  =   0; grn[2]  =   0; blu[2]  = 255; /* confirmed */
    red[3]  =   0; grn[3]  =   0; blu[3]  = 255; /* confirmed */
    red[4]  =   0; grn[4]  =   0; blu[4]  = 255; /* confirmed */
    red[5]  =   0; grn[5]  =   0; blu[5]  = 255; /* confirmed */
    red[6]  =   0; grn[6]  =   0; blu[6]  = 255; /* confirmed */
    red[7]  =   0; grn[7]  =   0; blu[7]  = 255; /* confirmed */
    red[8]  =   0; grn[8]  =   0; blu[8]  = 255; /* confirmed */
    red[9]  =   0; grn[9]  =   0; blu[9]  = 255; /* confirmed */
    red[10] =   0; grn[10] =   0; blu[10] = 255; /* confirmed */
    red[11] =   0; grn[11] =   0; blu[11] = 255; /* confirmed */
    red[12] = 255; grn[12] = 128; blu[12] =   0; /* believed unused */
    red[13] = 255; grn[13] = 128; blu[13] =   0; /* believed unused */
    red[14] = 255; grn[14] = 128; blu[14] =   0; /* believed unused */
    red[15] =   0; grn[15] =   0; blu[15] = 255; /* confirmed */
    red[16] = 255; grn[16] = 128; blu[16] =   0; /* believed unused */
    red[17] =   0; grn[17] =   0; blu[17] = 255; /* confirmed */
    red[18] = 255; grn[18] = 128; blu[18] =   0; /* believed unused */
    red[19] =   0; grn[19] =   0; blu[19] = 255; /* confirmed */
    red[20] = 255; grn[20] = 128; blu[20] =   0; /* believed unused */
    red[21] =   0; grn[21] =   0; blu[21] = 255; /* confirmed */
    red[22] =   0; grn[22] =   0; blu[22] = 255; /* confirmed */
    red[23] = 255; grn[23] = 128; blu[23] =   0; /* believed unused */
    red[24] = 255; grn[24] = 128; blu[24] =   0; /* believed unused */
    red[25] = 255; grn[25] = 128; blu[25] =   0; /* believed unused */
    red[26] =   0; grn[26] =   0; blu[26] = 255; /* confirmed */
    red[27] =   0; grn[27] =   0; blu[27] = 255; /* confirmed */
    red[28] = 255; grn[28] = 128; blu[28] =   0; /* believed unused */
    red[29] = 255; grn[29] = 128; blu[29] =   0; /* believed unused */
    red[30] = 255; grn[30] = 128; blu[30] =   0; /* believed unused */
    red[31] = 255; grn[31] = 128; blu[31] =   0; /* believed unused */
    red[32] =   0; grn[32] =   0; blu[32] = 255; /* confirmed */
    red[33] =   0; grn[33] =   0; blu[33] = 255; /* confirmed */
    red[34] =   0; grn[34] =   0; blu[34] = 255; /* confirmed */
    red[35] =   0; grn[35] =   0; blu[35] = 255; /* confirmed */
    red[36] =   0; grn[36] =   0; blu[36] = 255; /* confirmed */
    red[37] =   0; grn[37] =   0; blu[37] = 255; /* confirmed */
    red[38] =   0; grn[38] =   0; blu[38] = 255; /* confirmed */
    red[39] =   0; grn[39] =   0; blu[39] = 255; /* confirmed */
    red[40] =   0; grn[40] =   0; blu[40] = 255; /* confirmed */
    red[41] =  64; grn[41] = 255; blu[41] =   0; /* confirmed */
    red[42] = 255; grn[42] = 255; blu[42] =   0; /* confirmed */
    red[43] = 255; grn[43] =   0; blu[43] =   0; /* confirmed */
    red[44] = 255; grn[44] = 128; blu[44] =   0; /* believed unused */

    row = 0;
    cb = 0;
    sb = 0;

    coord_count = 0;

    /* open output files */

   /*********************************
   tags_fp = fopen(tags_file, "w"); 
   *********************************/
   
   link_fp = fopen(link_file, "w"); 

    /* read */

    while (!feof(stdin)) {

        i = 0;
        lim = 4096;

        while (--lim > 0 && (c = getc(stdin)) != EOF 
          && c != (int)'{'
          && c != (int)'}'
          && c != (int)'['
          && c != (int)']'
          ) {
            temp_buffer[i++] = (char)c;
            }
        temp_buffer[i] = '\0';
        if (c == (int)'{')
            cb++;
        if (c == (int)'}')
            cb--;
        if (c == (int)'[')
            sb++;
        if (c == (int)']')
            sb--;

        if (Debug != FALSE) {
            fprintf(stderr, "%s: DEBUG: cb:%d sb:%d temp_buffer: %s\n",
               argv[0], cb, sb, temp_buffer);
            }

        if ((cb == 3) && (sb == 2)
          && temp_buffer[0] != '"'
          ) {
            strip_char(temp_buffer, ',');

            sscanf(temp_buffer, "%s %s",
              &lat[coord_count][0], &lon[coord_count][0]);

            coord_count++;
            }

        if ((cb == 2) && (sb == 1)
          && temp_buffer[0] != EOS
          && temp_buffer[0] != ','
          && temp_buffer[0] != ' '
          ) {

            /* "LOC": "1", "FID": 0 */
            /* "SensorType": 1, "SensorName": 2, "stime": "201405081142", "FID": 0, "etime": "201405081524" */

            sscanf(temp_buffer, "%s %s %s %s", h1, d1, h2, d2);

            strip_char(h1, '"');
            strip_char(h1, ':');
            strip_char(h1, ',');

            strip_char(d1, '"');
            strip_char(d1, ':');
            strip_char(d1, ',');

            strip_char(h2, '"');
            strip_char(h2, ':');
            strip_char(h2, ',');

            strip_char(d2, '"');
            strip_char(d2, ':');
            strip_char(d2, ',');

            /* write this bunch */

            if (Debug != FALSE) {
                fprintf(stderr, "DEBUG: d1:>%s<\n", d1);
                fprintf(stderr, "DEBUG: coord_count:%d\n", coord_count);
                }

            dn = atoi(&d1[0]);

            if (dn >= 0 && dn <= 15) {

                if (coord_count <= 10) {
                    denom = 1;
                    }
                /****************************
                else if (coord_count <= 20) {
                    denom = 5;
                    }
                ****************************/
                else {
                    denom = 5;
                    }

                ncc = 0;
                for (cc = 0; cc < coord_count; cc++) {
                    if (cc%denom == 0) {
                        strcpy(&new_lat[ncc][0], &lat[cc][0]);
                        strcpy(&new_lon[ncc][0], &lon[cc][0]);
                        ncc++;
                        }
                    }
                new_coord_count = ncc;

                for (timecode = 0; timecode <= 1; timecode++) {
                    for (cc = 0; cc < new_coord_count; cc++) {
                        row++;
                        if (cc == (new_coord_count - 1)) {
                           r2 = row - new_coord_count + 1;
                           }
                        else {
                           r2 = row + 1;
                           }

                        /* KLUDGE */

                        if (h1[0] == 'S') {
                           Base = 40;
                           }
                        else {
                           Base = 0;
                           }

                        ndn = dn + Base;

                        /* ndn = dn; */

                        /* data file */

                        fprintf(stdout, "%s,%s,%d,%d,%d,%d,%d,%s\n",
                          new_lat[cc], new_lon[cc],
                          red[ndn], grn[ndn], blu[ndn],
                          ndn, timecode, d2);

                        /* links file */

                        fprintf(link_fp,
                          "%d,%d,%f,%d,%d,%d,row:%d_r2:%d_cc:%d_co:%d\n",
                          row, r2, Size, red[ndn], grn[ndn], blu[ndn],
                          row, r2, cc, new_coord_count);

                        if (timecode == 1) {
                            fprintf(link_fp,
                              "%d,%d,%f,%d,%d,%d,row:%d_vert\n",
                              row, row - new_coord_count, Size,
                              red[ndn], grn[ndn], blu[ndn], row);
                            }

                        }
                    }

                coord_count = 0;
                }
            }

        }

    } /* end main */

/*
 *  defaultParms - initialize global variables
 */
defaultParms()
{
    Debug = FALSE;

    Base = 0;
    Size = 1.0;

    } /* end defaultParms() */

/*
 *  parseArgs - parse arguments into global variables
 */
parseArgs(argc, argv)
int argc;
char** argv;
{
    int i;

    for (i = 0; i < argc; i++) {
        if (argv[i][0] == '-') {
            switch (argv[i][1]) {
                case 'D' : Debug = TRUE;
                           break;
                case 'h' : help(argv);
                           exit(0);
                           break;
                case 'b' : Base = atoi(&argv[++i][0]);
                           break;
                case 's' : Size = atof(&argv[++i][0]);
                           break;
                case 'u' : usage(argv);
                           exit(0);
                           break;
                default:   fprintf(stderr, "%s: ERROR: illegal flag: %s\n",
                               argv[0], argv[i]);
                           usage(argv);
                           exit(0);
                           break;
                } /* end switch */
            } /* end if */
        } /* end for(i) */
    } /* end parseArgs() */

/*
 * getl - modified from Kernighan & Ritchie to take stream
 */
int
getl(stream, s, lim)            /* get line into s, return length */
FILE *stream;
char s[];
int lim;
{
    int c, i;

    i = 0;
    while (--lim > 0 && (c = getc(stream)) != EOF && c != '\n')
        s[i++] = c;
    if (c == '\n')
        s[i++] = c;
    s[i] = '\0';
    return(i);
    } /* end getl() */

/*
 * strip_char
 */
void strip_char(target_string, single_char)
char *target_string;
char single_char;
{
    int i, j;
    char temp_string[4096];

#ifdef SUPER_DEBUG
    if (Debug != FALSE) {
        fprintf(stderr,
          "strip_char(): DEBUG: single_char = >%c<\n",
          single_char);
        fprintf(stderr,
          "strip_char(): DEBUG: old target_string = >%s<\n",
          target_string);
        fprintf(stderr,
          "strip_char(): DEBUG: old strlen(target_string) = %d\n",
          strlen(target_string));
        }
#endif

    j = 0;

    for  (i = 0; i < strlen(target_string); i++) {
        if (target_string[i] != single_char) {
            temp_string[j++] = target_string[i];
            }
        }
    temp_string[j] = (char)EOS;

    for  (j = 0; j < strlen(temp_string); j++) {
        target_string[j] = temp_string[j];
        }
    target_string[j] = (char)EOS;

#ifdef SUPER_DEBUG
    if (Debug != FALSE) {
        fprintf(stderr,
          "strip_char(): DEBUG: new target_string = >%s<\n",
          target_string);
        fprintf(stderr,
          "strip_char(): DEBUG: new strlen(target_string) = %d\n",
          strlen(target_string));
        fprintf(stderr,
          "strip_char(): DEBUG: temp_string = >%s<\n",
          target_string);
        fprintf(stderr,
          "strip_char(): DEBUG: strlen(temp_string) = %d\n",
          strlen(temp_string));
        }
#endif

    }
----------------------------------------------
json2glyph_in.h
----------------------------------------------
/*
 * json2glyph_in.h -- include file for json2glyph_in.c
 */

/* includes */

#include        <stdio.h>
#include        <ctype.h>
#include        <stdlib.h>
#include        <string.h>
#include        <math.h>
#include        <errno.h>

/* constants */

#define TRUE        (1)
#define FALSE       (0)

#define EOS         (0)

/* global variables */

/* flag-settable parameters (global variables) */

int Debug;              /* Boolean: TRUE = debug writes */
int Base;               /* int */
float Size;             /* float */
----------------------------------------------
Makefile
----------------------------------------------
O_FILES = json2glyph_in.o usage.o help.o
CFLAGS = 
CC = gcc

json2glyph_in:	$(O_FILES)
	$(CC) $(CFLAGS) -o json2glyph_in $(O_FILES)
----------------------------------------------
Test
----------------------------------------------
#
./json2glyph_in.exe -D -b  0 < TS14_NAIs.json > test_N.txt
----------------------------------------------