src/src/gshhs_extractor.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.

// gshhs_extractor.cc : GSHHS extractor

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

#include "common.hpp"
#include "gshhs.hpp"
#include "opt.hpp"

class GOpts : public Options
{
public:
        int skip_id;
        bool smoothing;
        
public:
        GOpts() { 
                skip_id = -1;
                smoothing = true;
        }

        void checkOptions(void) {
                if (check("i", "skip-id")) {
                        skip_id = atoi(shift());
                }
                else if (check("n", "no-smoothing")) {
                        smoothing = false;
                }
                else {
                        Options::checkOptions();
                }
        }

        void usage(void) {
                Options::usage();

                optusage("i", "skip-id", "Specify last polygon number to be skipped");
                optusage("n", "no-smoothing", "Do not execute polygon smoothing");
        }
};

static void banner(void)
{
        fprintf(stderr,
                "GSHHS data extractor for autocoast.\n" \
                "  Copyright (C) 2004, Takuya Murakami. All rights reserved.\n\n"
                );
}


/* main */      
int main(int argc, char *argv[])
{
        BoundingBox bbox;

        banner();

        GOpts opts;
        opts.set_arg_help("datafile west east south north");
        opts.parse(&argc, &argv);

        if (argc != 6) {
                opts.usage();
                exit(1);
        }

        // get arg
        const char *fname = argv[1];
        bbox.xmin = atof(argv[2]);
        bbox.xmax = atof(argv[3]);
        bbox.ymin = atof(argv[4]);
        bbox.ymax = atof(argv[5]);

        if (bbox.xmin >= bbox.xmax ||
            bbox.ymin >= bbox.ymax ||
            bbox.xmin < -180 || bbox.xmax > 360 ||
            bbox.ymin < -90 || bbox.ymax > 90
                ) {
                fprintf(stderr, "Invalid lat/lon.\n");
                exit(1);
        }
        if (bbox.xmin < 0) {
                if (bbox.xmax > 0) {
                        fprintf(stderr, "You can't cross greenwich.\n");
                        exit(1);
                }

                bbox.xmin += 360.0;
                bbox.xmax += 360.0;
        }

        // create cropping box
        BoundingBox crop;
        crop.xmin = bbox.xmin - 2.0;
        crop.xmax = bbox.xmax + 2.0;
        crop.ymin = bbox.ymin - 2.0;
        crop.ymax = bbox.ymax + 2.0;

        GPolygon polygon;

        for (int level = 1; level <= 4; level++) {
                // Load GSHHS data
                fprintf(stderr, "Extracting level = %d\n", level);
                fprintf(stderr, "* Reading data...\n");
                polygon.LoadFromGshhsBinary(fname, level, bbox, opts.skip_id);

                polygon.printStat();

                // Smoothing
                if (opts.smoothing) {
                        fprintf(stderr, "* Smoothing...\n");
                        polygon.Smoothing();
                }

                // Cropping points
                fprintf(stderr, "* Cropping points...\n");
                polygon.Crop(crop);

                polygon.printStat();

                // Clipping
                fprintf(stderr, "* Clipping...\n");
                GpcPolygon *clipped = polygon.Clipping(bbox);

                clipped->printStat();

                // Write result
                fprintf(stderr, "* Writing...\n");
                char outfile[128];
                sprintf(outfile, "level%d.gpc", level);
                clipped->SaveToFile(outfile);

                delete clipped;
                polygon.clear();
        }
}