geometry_2d.h

Go to the documentation of this file.

/*
 * geometry_2d.h
 *
 * Copyright (C) 2003,2008 Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''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 THOMAS A. VAUGHAN 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.
 *
 *
 * Basic 2D geometry.
 */

#ifndef WAVEPACKET_GEOMETRY_2D_H__
#define WAVEPACKET_GEOMETRY_2D_H__


// includes --------------------------------------------------------------------
#include "common/common.h"

#include <iostream>

#include <math.h>

/// \ingroup geometric
/*@{*/


////////////////////////////////////////////////////////////////////////////////
///
/// \defgroup geometry Core Geometry Objects
///
/// This module contains general geometry primitives for use in 2D or 3D
/// spaces.
///
////////////////////////////////////////////////////////////////////////////////
/*@{*/



////////////////////////////////////////////////////////////////////////////////
//
//      Basic types
//
////////////////////////////////////////////////////////////////////////////////

/**
 * Template for two-dimensional point.
 */
template <class T>
struct point2d_t {
        // constructors, manipulators
        point2d_t(IN T in_x = 0, IN T in_y = 0) throw() :
            x(in_x),
            y(in_y)
                { }
        point2d_t(IN const point2d_t& pt) throw() :
            x(pt.x),
            y(pt.y)
                { }

        void set(IN T in_x, IN T in_y) throw() {
                        x = in_x;
                        y = in_y;
                }

        void clear(void) throw() {
                x = y = 0;
                }

        /**
         * dumps contents to stderr
         */
        void dump(const char * title) const throw() {
                        DPRINTF("  %s: (%5.2f, %5.2f)", title, x, y);
                }

        /**
         * vector subtraction
         */
        point2d_t operator - (IN const point2d_t& rhs) const throw() {
                        return point2d_t(x - rhs.x, y - rhs.y);
                }

        /**
         * vector addition
         */
        point2d_t operator + (IN const point2d_t& rhs) const throw() {
                        return point2d_t(x + rhs.x, y + rhs.y);
                }

        void normalize(void) throw() {
                        float mag = sqrt((x * x) + (y * y));
                        if (mag) {
                                x = (T) (x / mag);
                                y = (T) (y / mag);
                        }
                }

        // static operators
        static T dotProduct(IN const point2d_t& u,
                                IN const point2d_t& v) throw() {
                        return (u.x * v.x) + (u.y * v.y);
                }

        // data fields
        T       x;
        T       y;
};



/// templated 2D rectangle
template <class T>
struct rect2d_t {
        typedef point2d_t<T> point_t;

        // constructors
        rect2d_t(void) throw() { }
        rect2d_t(IN T iLeft, IN T iTop, IN T iRight, IN T iBottom) throw() {
                        left = iLeft;
                        top = iTop;
                        right = iRight;
                        bottom = iBottom;
                }

        /// expand rect to fully contain input rect
        void inflate(IN const rect2d_t& r) throw() {
                        if (left > r.left)
                                left = r.left;
                        if (right < r.right)
                                right = r.right;
                        if (top > r.top)
                                top = r.top;
                        if (bottom < r.bottom)
                                bottom = r.bottom;
                }

        /// valid?
        bool isValid(void) const throw() {
                        return ((right >= left) && (bottom >= top));
                }

        /// expand rect in all dimensions by provided amount
        void expand(IN T s) throw() {
                        left -= s;
                        right += s;
                        top -= s;
                        bottom += s;
                }

        /// null size?
        bool isEmpty(void) const throw() {
                        if (left == right ||
                            top == bottom)
                                return true;
                        return false;
                }

        /// move rect by specified dx,dy amount
        void shift(IN T dx, IN T dy) throw() {
                        left += dx;
                        top += dy;
                        right += dx;
                        bottom += dy;
                }

        /// does this rect contain the specified point?
        bool contains(IN const point_t& pt) const throw() {
                        if (pt.x >= left && pt.x <= right &&
                            pt.y >= top && pt.y <= bottom)
                                return true;
                        return false;
                }

        /// does this rect contain the specified point?
        bool contains(IN float x, IN float y) const throw() {
                        return this->contains(point_t(x, y));
                }

        /// does this rect fully contain the specified rect?
        bool contains(IN const rect2d_t& r) const throw() {
                        return (left <= r.left &&
                                right >= r.right &&
                                top <= r.top &&
                                bottom >= r.bottom);
                }

        /// does this rect intersect the specified rect?
        bool intersects(IN const rect2d_t& r) const throw() {
                        if (left < r.right &&
                            right > r.left &&
                            top < r.bottom &&
                            bottom > r.top)
                                return true;
                        return false;
                }

        /// expand to include the given point
        void expandToInclude(IN const point_t& p) throw() {
                        this->expandToInclude(p.x, p.y);
                }

        /// expand to include the given point
        void expandToInclude(IN T x, IN T y) throw() {
                        left =(x < left) ? x : left;
                        top = (y < top) ? y : top;
                        right = (x > right) ? x : right;
                        bottom = (y > bottom) ? y : bottom;
                }

        /// explicitly set the rect coordinates
        void set(IN T in_left, IN T in_top,
                        IN T in_right, IN T in_bottom) throw() {
                        left = in_left;
                        top = in_top;
                        right = in_right;
                        bottom = in_bottom;
                }

        /// minimum bounding rect containing the two points
        void fromPoints(IN const point_t& p0, IN const point_t& p1) throw() {
                        left = (p0.x < p1.x) ? p0.x : p1.x;
                        top = (p0.y < p1.y) ? p0.y : p1.y;
                        right = (p0.x > p1.x) ? p0.x : p1.x;
                        bottom = (p0.y > p1.y) ? p0.y : p1.y;
                }

        /// scale out in X and Y directions
        void scale(IN float rX, IN float rY) throw() {
                        left *= rX;
                        top *= rY;
                        right *= rX;
                        bottom *= rY;
                }

        /// reset rect to be null rectangle at (0,0)
        void clear(void) throw() { this->set(0, 0, 0, 0); }

        /// debug helper to dump rectangle to std err
        void dump(IN const char * title) const throw() {
                        std::cerr << title << ": (" << left << ", " << top;
                        std::cerr << ") - (" << right << ", " << bottom;
                        std::cerr << ")\n";
                }

        /// return top left coordinate
        point_t getTopLeft(void) const throw() {
                        return point_t(left, top);
                }

        /// return top right coordinate
        point_t getBottomRight(void) const throw() {
                        return point_t(right, bottom);
                }

        // data fields
        T       left;
        T       top;
        T       right;
        T       bottom;
};



#endif  // WAVEPACKET_GEOMETRY_2D_H__