src/src/autocoast.cpp

//
// AutoCoast: Automatic Coastline scenery generator for Flight Simulator
//
// Copyright (c) 2004, Takuya Murakami. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// autocoast.cc : main

#include <stdio.h>
#include <stdlib.h>

#include "cell.hpp"
#include "opt.hpp"

AcOptions       AcOpts;

static void WriteBGL(LwmBgl *lwm, VtpBgl *vtp, FILE *batfile, int u, int v, int u2, int v2);

static void banner(void)
{
        fprintf(stderr, BANNER);
}

// main func
int main(int argc, char **argv)
{
        char *argv0;
        int u, v, min_u, min_v, max_u, max_v, num_u, num_v, num_cells;
        char filename[128];

        banner();

        AcOpts.set_arg_help("west north [east] [south]");

        AcOpts.parse(&argc, &argv);

        if (argc < 3 || argc > 5) {
                AcOpts.usage();
                exit(1);
        }
        
        if (AcOpts.useDegree) {
                min_u = Cell::lon2x(atof(argv[1]));
                min_v = Cell::lat2y(atof(argv[2]));
                max_u = (argc > 3) ? Cell::lon2x(atof(argv[3])) : min_u;
                max_v = (argc > 4) ? Cell::lat2y(atof(argv[4])) : min_v;
        } else {
                min_u = atoi(argv[1]);
                min_v = atoi(argv[2]);
                max_u = (argc > 3) ? atoi(argv[3]) : min_u;
                max_v = (argc > 4) ? atoi(argv[4]) : min_v;
        }

        fprintf(stderr, "cells: [%d,%d] - [%d, %d]\n", min_u, min_v, max_u, max_v);

        if (min_u < 0 || max_u < min_u || 768 <= max_u) {
                fprintf(stderr, "Invalid u (longitude) value\n");
                exit(1);
        }
        if (min_v < 0 || max_v < min_v || 512 <= max_v) {
                fprintf(stderr, "Invalid v (latitude) value\n");
                exit(1);
        }


        num_u = max_u - min_u + 1;
        num_v = max_v - min_v + 1;
        num_cells = num_u * num_v;

        // Load dataset
        fprintf(stderr, "* Loading dataset\n");
        DataSet source;
        source.LoadData();
        
        source.printStat();
        fprintf(stderr, "\n");

        // Create cell data
        Cell *cells = new Cell[num_cells];
        #define CELL(u, v) cells[(u - min_u) + (v - min_v) * num_u]
        Cell *c;

        BoundingBox bbox;

        for (v = min_v; v <= max_v; v++) {
                for (u = min_u; u <= max_u; u++) {
                        c = &CELL(u, v);
                        c->setid(u, v);
                        bbox.extend(c->getBoundingBox());
                }
        }

        // open batch file
        FILE *batfile = fopen("compile.bat", "w");
        if (!batfile) {
                fprintf(stderr, "Can't open file: compile.bat\n");
                exit(1);
        }

        // Clipping (1st stage: whole cells)
        fprintf(stderr, "* Global clipping\n");
        DataSet *clipped = source.Clipping(bbox);
        clipped->printStat();
        fprintf(stderr, "\n");

        LwmBgl *lwm = new LwmBgl;
        VtpBgl *vtp = new VtpBgl;

        int i = 1;
        for (v = min_v; v <= max_v; v++) {

                // Clipping (2nd stage: one cell line)
                c = &CELL(min_u, v);
                BoundingBox bbox_line = *(c->getBoundingBox());

                c = &CELL(max_u, v);
                bbox_line.extend(c->getBoundingBox());

                DataSet *clipped_line = clipped->Clipping(bbox_line);
                //clipped_line->printStat();
                //fprintf(stderr, "\n");

                // Process each cells
                for (u = min_u; u <= max_u; u++) {
                        c = &CELL(u, v);
                        fprintf(stderr, "%d/%d: Cell[%d:%d] ", i, num_cells, u, v);
                        
                        // Clipping (3rd stage: each cell)
                        if (!c->Clipping(clipped_line)) {
                                // data empty : do nothing
                                fprintf(stderr, "no data\n");
                        }
                        else {
                                // generate data
                                c->GenLwmBgl(lwm);
                                c->GenVtpBgl(vtp);
                                fprintf(stderr, "\n");

                                if (AcOpts.splitBgl) {
                                        WriteBGL(lwm, vtp, batfile, u, v, -1, -1);

                                        delete lwm;
                                        delete vtp;

                                        lwm = new LwmBgl;
                                        vtp = new VtpBgl;
                                }
                        }
                        
                        c++;
                        i++;
                }
                delete clipped_line;
        }

        if (!AcOpts.splitBgl) {
                WriteBGL(lwm, vtp, batfile, min_u, min_v, max_u, max_v);
        }

        fclose(batfile);

        delete lwm;
        delete vtp;
        delete [] cells;

        return 0;
}

static void WriteBGL(LwmBgl *lwm, VtpBgl *vtp, FILE *batfile, int u, int v, int u2, int v2)
{
        char filename[128];

        if (u2 < 0) {
                sprintf(filename, "lwm_%d_%d.asm", u, v);
        } else {
                sprintf(filename, "lwm_%d_%d_%d_%d.asm", u, v, u2, v2);
        }
        lwm->WriteBGL(filename);
        fprintf(batfile, "bglc %s\n", filename);

        if (u2 < 0) {
                sprintf(filename, "vtp_%d_%d.asm", u, v);
        } else {
                sprintf(filename, "vtp_%d_%d_%d_%d.asm", u, v, u2, v2);
        }
        vtp->WriteBGL(filename);
        fprintf(batfile, "bglc %s\n", filename);
}