geometry_3d.h

Go to the documentation of this file.

/*
 * geometry_3d.h
 *
 * Copyright (C) 2006-2010  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.
 *
 *
 * primitives for 3D geometry.
 */

#ifndef WAVEPACKET_GEOMETRY_3D_H__
#define WAVEPACKET_GEOMETRY_3D_H__

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

#include <math.h>


/// \ingroup geometry
/*@{*/


/// this enum can be used for some intersection/containment tests
enum eContains {
        eContains_Fully         = 0x01,  ///< object A fully contains object B
        eContains_Partial       = 0x02,  ///< objects A and B intersect or overlap
        eContains_None          = 0x10,  ///< object A and B do not overlap at all

        // any sort of intersection
        eContains_HitMask       = 0x03,  ///< full or partial overlap

        // keep this last!
        eContains_Invalid       = 0
};


/// basic 3D point object.  Unlike 2D points, this is not a template.  It is
/// expected that users of this class are modeling 3D space and needing only
/// modest accuracy, hence floats.
///
/// \b WARNING: the default constructor does NOT initialize the point to any
/// particular value (such as <tt>(0, 0, 0)</tt> ).  This is by design, so people
/// can allocate large point3d_t arrays without paying a construction cost.
/// Just be aware that this code:
/// \code
///    point3d_t p;
/// \endcode
/// means that the value of p is undefined, and is probably quite large and
/// random.
struct point3d_t {
        // constructors
        point3d_t(void) throw() { }
        point3d_t(IN float ix, IN float iy, IN float iz) throw() :
            x(ix), y(iy), z(iz) { }

        // manipulators
        void clear(void) throw() {
                        x = y = z = 0.0;
                }

        void set(IN float ix, IN float iy, IN float iz) throw() {
                        x = ix;         y = iy;         z = iz;
                }

        void dump(IN const char * title) const throw() {
                        DPRINTF("%s (%f, %f, %f)", title, x, y, z);
                }

        void increment(IN const point3d_t& p) throw() {
                        x += p.x;
                        y += p.y;
                        z += p.z;
                }

        void decrement(IN const point3d_t& p) throw() {
                        x -= p.x;
                        y -= p.y;
                        z -= p.z;
                }

        void scale(IN float r) throw() {
                        x *= r;
                        y *= r;
                        z *= r;
                }

        void operator *= (IN float r) throw() { this->scale(r); }

        void operator += (IN const point3d_t& p) throw() {
                        increment(p);
                }

        void operator -= (IN const point3d_t& p) throw() {
                        decrement(p);
                }

        point3d_t operator - (void) const throw() {
                        return point3d_t(-x, -y, -z);
                }

        // data fields
        float   x;
        float   y;
        float   z;
};


// operations using points
point3d_t operator * (IN const point3d_t& p, IN float r) throw();
inline point3d_t operator * (IN float r, IN const point3d_t& p) throw() {
        return p * r;
}

inline point3d_t operator + (IN const point3d_t& p, IN const point3d_t& q) throw()
{
        return point3d_t(p.x + q.x, p.y + q.y, p.z + q.z);
}

inline point3d_t operator - (IN const point3d_t& p, IN const point3d_t& q) throw()
{
        return point3d_t(p.x - q.x, p.y - q.y, p.z - q.z);
}

/// get dot product of two points/vectors
inline float dotProduct(IN const point3d_t& p, IN const point3d_t& q) throw()
{
        return (p.x * q.x) + (p.y * q.y) + (p.z * q.z);
}


inline point3d_t
crossProduct(IN const point3d_t& p, IN const point3d_t& q) throw()
{
        point3d_t r;
        r.x = p.y * q.z - p.z * q.y;
        r.y = p.z * q.x - p.x * q.z;
        r.z = p.x * q.y - p.y * q.x;
        return r;
}



typedef point3d_t vector3d_t;


/// standard 3D axis-aligned rectangle (also called axis-aligned bounding box,
///     AABB)
struct rect3d_t {
        // public enum
        enum eConstants {
                eMaxCorners     =  8,
                eMaxEdges       = 12
        };

        // manipulators
        void clear(void) throw() {
                        x0 = y0 = z0 = x1 = y1 = z1 = 0.0;
                }

        void dump(IN const char * title) const throw() {
                        DPRINTF("%s (%f, %f, %f) - (%f, %f, %f)",
                            title, x0, y0, z0, x1, y1, z1);
                }

        bool isValid(void) const throw() {
                        return ((x1 >= x0) && (y1 >= y0) && (z1 >= z0));
                }

        void validate(IN const char * msg = NULL) const throw() {
                        if (!this->isValid()) {
                                this->dump("Invalid!");
                                ASSERT(false, "rect validation failed: %s", msg);
                        }
                }

        bool containsPoint(IN const point3d_t& p) const throw() {
                        return (p.x >= x0 && p.x <= x1 &&
                                p.y >= y0 && p.y <= y1 &&
                                p.z >= z0 && p.z <= z1);
                }

        bool intersectsRect(IN const rect3d_t& r) const throw() {
                        if (r.x1 < x0 ||
                            r.x0 > x1 ||
                            r.y1 < y0 ||
                            r.y0 > y1 ||
                            r.z1 < z0 ||
                            r.z0 > z1)
                                return false;
                        return true;
                }

        bool containsRect(IN const rect3d_t& r) const throw() {
                        return (r.x0 >= x0 &&
                                r.x1 <= x1 &&
                                r.y0 >= y0 &&
                                r.y1 <= y1 &&
                                r.z0 >= z0 &&
                                r.z1 <= z1);
                }

        void expand(IN const rect3d_t& r) throw() {
                        this->validate();
                        r.validate();
                        if (r.x0 < x0)
                                x0 = r.x0;
                        if (r.y0 < y0)
                                y0 = r.y0;
                        if (r.z0 < z0)
                                z0 = r.z0;

                        if (r.x1 > x1)
                                x1 = r.x1;
                        if (r.y1 > y1)
                                y1 = r.y1;
                        if (r.z1 > z1)
                                z1 = r.z1;
                }

        void inflate(IN float r) throw() {
                        x0 -= r;        x1 += r;
                        y0 -= r;        y1 += r;
                        z0 -= r;        z1 += r;
                }

        void setToPoint(IN const point3d_t& p) throw() {
                        x0 = x1 = p.x;
                        y0 = y1 = p.y;
                        z0 = z1 = p.z;
                }

        void includePoint(IN const point3d_t& p) throw() {
                        if (p.x < x0)
                                x0 = p.x;
                        if (p.x > x1)
                                x1 = p.x;
                        if (p.y < y0)
                                y0 = p.y;
                        if (p.y > y1)
                                y1 = p.y;
                        if (p.z < z0)
                                z0 = p.z;
                        if (p.z > z1)
                                z1 = p.z;
                }

        void getBoundingRectForSphere(IN const point3d_t& center,
                                IN float radius) throw() {
                        ASSERT(radius >= 0.0, "Bad radius: %f", radius);
                        x0 = center.x - radius;
                        x1 = center.x + radius;
                        y0 = center.y - radius;
                        y1 = center.y + radius;
                        z0 = center.z - radius;
                        z1 = center.z + radius;
                }

        point3d_t getMidpoint(void) const throw() {
                        return point3d_t(0.5 * (x0 + x1),
                                         0.5 * (y0 + y1),
                                         0.5 * (z0 + z1));
                }

        float getDiagonal(void) const throw() {
                        float dx = x1 - x0;
                        float dy = y1 - y0;
                        float dz = z1 - z0;
                        float d2 = (dx * dx) + (dy * dy) + (dz * dz);
                        return sqrt(d2);
                }

        /// restricts the given point to be within the rectangle
        void restrictPoint(IO point3d_t& p) const throw() {
                        // this->validate();
                        if (p.x < x0)
                                p.x = x0;
                        if (p.x > x1)
                                p.x = x1;
                        if (p.y < y0)
                                p.y = y0;
                        if (p.y > y1)
                                p.y = y1;
                        if (p.z < z0)
                                p.z = z0;
                        if (p.z > z1)
                                p.z = z1;
                }

        /// given an index 0 <= index <= eMaxCorners, returns the corner point
        point3d_t getCorner(IN int index) const throw();

        /// given an index 0 <= index <= eMaxEdges, returns the two edge
        ///     endpoints
        void getEdge(IN int index,
                                OUT point3d_t& p0,
                                OUT point3d_t& p1) const throw();

        void translate(IN const point3d_t& delta) throw() {
                        x0 += delta.x;
                        x1 += delta.x;
                        y0 += delta.y;
                        y1 += delta.y;
                        z0 += delta.z;
                        z1 += delta.z;
                }

        // data fields
        float   x0;
        float   y0;
        float   z0;
        float   x1;
        float   y1;
        float   z1;
};


////////////////////////////////////////////////////////////////////////////////
//
//      3d helper methods
//
////////////////////////////////////////////////////////////////////////////////

// normalize(v) -- normalizes vector, and returns reference to it
const vector3d_t& normalize(IO vector3d_t& v) throw();

static inline float
getDistance2
(
IN const point3d_t& p0,
IN const point3d_t& p1
)
throw()
{
        float dx = p0.x - p1.x;
        float dy = p0.y - p1.y;
        float dz = p0.z - p1.z;

        return (dx * dx) + (dy * dy) + (dz * dz);
}


point3d_t readPoint(IN std::istream& stream);
rect3d_t  readRect(IN std::istream& stream);

void parsePoint3d(IO std::istream& stream, OUT point3d_t& p);
void parseRect3d(IO std::istream& stream, OUT rect3d_t& r);

void parsePoint3d(IN const char * string, OUT point3d_t& p);
void parseRect3d(IN const char * string, OUT rect3d_t& r);

#endif  // WAVEPACKET_GEOMETRY_3D_H__