src/lib/gshhs.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.cc : GSHHS process

#include <stdio.h>
#include <stdlib.h>
//#include <netinet/in.h>
#include "common.hpp"
#include "gshhs.hpp"

static double u2d(int u)
{
        return (double)u * 1.0e-6;
}

////////////////////////////////////////////////////////////////////
// GVertexList
//
GVertexList::GVertexList(void)
        : GpcVertexList(0, NULL)
{
        /* do nothing */
}

GVertexList::~GVertexList(void)
{
}

bool GVertexList::readHeader(FILE *fp)
{
        if (fread(&header, sizeof(header), 1, fp) == 0) {
                return false;   // EOF
        }

        header.id       = ntohl(header.id);
        header.num      = ntohl(header.num);
        header.level    = htonl(header.level);
        header.xmin     = htonl(header.xmin);
        header.xmax     = htonl(header.xmax);
        header.ymin     = htonl(header.ymin);
        header.ymax     = htonl(header.ymax);
        header.area     = htonl(header.area);
        header.greenwich= htons(header.greenwich);
        header.source   = htons(header.source);

        bbox.xmin = u2d(header.xmin);
        bbox.xmax = u2d(header.xmax);
        bbox.ymin = u2d(header.ymin);
        bbox.ymax = u2d(header.ymax);

        return true;
}

void GVertexList::printHeader(void)
{
        printf("P I:%6d N:%8d L:%2d %s W:%-8.3f E:%-8.3f S:%-8.3f N:%-8.3f\n",
               header.id, header.num, header.level,
               header.source == 1 ? "WVS" : "CIA",
               u2d(header.xmin), u2d(header.xmax), u2d(header.ymin), u2d(header.ymax));
}

bool GVertexList::readData(FILE *fp, bool skip, bool isWestHemisphere)
{
        vlist->num_vertices = header.num;
        if (skip) {
                fseek(fp, sizeof(int) * 2 * vlist->num_vertices, SEEK_CUR);
                return true;
        }

        if (vlist->vertex) {
                delete [] vlist->vertex;
        }
        vlist->vertex = new gpc_vertex[vlist->num_vertices];

        int i, p[2];
        for (i = 0; i < vlist->num_vertices; i++) {
                if (fread(p, sizeof(int), 2, fp) <= 0) {
                        // Ouch!
                        return false;
                }

                p[0] = ntohl(p[0]);
                p[1] = ntohl(p[1]);

                double x = u2d(p[0]);
                double y = u2d(p[1]);

                // When polygon is crossing greenwich?
                if (header.greenwich) {
                        // assure polygon continuity
                        if (x > 200.0) {
                                x -= 360.0;
                        }

                        // for west hemisphere, move polygon crossing greenwich.
                        if (isWestHemisphere) {
                                x += 360.0;
                        }
                }
                vlist->vertex[i].x = x;
                vlist->vertex[i].y = y;
        }
        return true;
}

bool GVertexList::inBound(BoundingBox &clip)
{
        if (!bbox.isCrossing(clip)) {
                return false;
        }
        return true;
}

bool GVertexList::inBoundVertices(BoundingBox &clip)
{
        // check all vertices
        int n = numVertices();
        for (int i = 0; i < n; i++) {
                if (clip.isInbox(vx(i), vy(i))) {
                        return true;
                }
        }
        return false;
}

////////////////////////////////////////////////////////////////////
// GPolygon
//
GPolygon::GPolygon()
{
        /* do nothing */
}

GPolygon::~GPolygon()
{
}

//
// Load GSHHS binary file
//
int GPolygon::LoadFromGshhsBinary(const char *fname, int level, BoundingBox &bbox, int skipid)
{
        FILE *fp = fopen(fname, "rb");
        if (!fp) {
                fprintf(stderr, "Can't open file: %s\n", fname);
                exit(1);
        }
        
        bool isWestHemisphere = false;
        if (bbox.xmin > 200.0) {
                isWestHemisphere = true;
        }

        GVertexList *vl = new GVertexList;

        while (vl->readHeader(fp)) {
                if (vl->level() != level ||
                    !vl->inBound(bbox) ||
                    vl->id() <= skipid) {
                        // skip this polygon
                        vl->readData(fp, true); 
                        continue;
                }

                vl->readData(fp, false, isWestHemisphere);

                if (vl->inBoundVertices(bbox)) {
                        vl->printHeader();
                        AddVertexList(vl, false);
                }

                delete vl;
                vl = new GVertexList;
        }
        delete vl;
        
        BuildVertexListFromGpcPolygon();

        fclose(fp);
        return 0;
}

//
// Save GPC data
//
int GPolygon::SaveGpcFile(const char *fname)
{
        GpcPolygon::SaveToFile(fname);
        return 0;
}