src/lib/bbox.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.

// bbox.cc : Bounding Box

#include "bbox.hpp"

BoundingBox::BoundingBox()
{
        xmin = 1.0e+12; xmax = -1.0e+12;
        ymin = 1.0e+12; ymax = -1.0e+12;
}

gpc_polygon *BoundingBox::createClipPolygon(void)
{
        gpc_vertex *vertex = new gpc_vertex[4];
        vertex[0].x = xmin; vertex[0].y = ymin;
        vertex[1].x = xmax; vertex[1].y = ymin;
        vertex[2].x = xmax; vertex[2].y = ymax;
        vertex[3].x = xmin; vertex[3].y = ymax;

        gpc_vertex_list *vlist = new gpc_vertex_list;
        vlist->num_vertices = 4;
        vlist->vertex = vertex;

        gpc_polygon *polygon = new gpc_polygon;
        polygon->num_contours = 1;
        polygon->contour = vlist;
        polygon->hole = NULL;

        return polygon;
}

void BoundingBox::destroyClipPolygon(gpc_polygon *polygon)
{
        delete polygon->contour->vertex;
        delete polygon->contour;
        delete polygon;
}

bool BoundingBox::isCrossing(BoundingBox &target)
{
        if (target.xmax <= xmin || xmax <= target.xmin ||
            target.ymax <= ymin || ymax <= target.ymin) {
                return false;
        }
        return true;
}

void BoundingBox::setpoint(double x, double y)
{
        if (xmin > x) xmin = x;
        if (xmax < x) xmax = x;

        if (ymin > y) ymin = y;
        if (ymax < y) ymax = y;
}       

void BoundingBox::extend(BoundingBox *target)
{
        if (target->xmin < xmin) xmin = target->xmin;
        if (target->xmax > xmax) xmax = target->xmax;
        if (target->ymin < ymin) ymin = target->ymin;
        if (target->ymax > ymax) ymax = target->ymax;
}


bool BoundingBox::isInbox(double x, double y)
{
        if (xmin <= x && x <= xmax &&
            ymin <= y && y <= ymax) {
                return true;
        }
        return false;
}

inline bool SAME(double a, double b)
{
        const double MARGIN = 1.0e-7;

        if (a - b > -MARGIN &&
            a - b < MARGIN) {
                return true;
        }
        return false;
}

bool BoundingBox::compare(BoundingBox &target)
{
        if (SAME(xmin, target.xmin) && SAME(xmax, target.xmax) &&
            SAME(ymin, target.ymin) && SAME(ymax, target.ymax)) {
                return true;
        }
        return false;
}

//
// On the edge of BoundingBox?
//
int BoundingBox::checkEdge(double x, double y)
{
        int flags = 0;

        if (SAME(x, xmin)) flags |= onLeftEdge;
        if (SAME(x, xmax)) flags |= onRightEdge;
        if (SAME(y, ymin)) flags |= onUpperEdge;
        if (SAME(y, ymax)) flags |= onBottomEdge;

        return flags;
}