geometry_3d.cpp

Go to the documentation of this file.

/*
 * geometry_3d.cpp
 *
 * 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.
 *
 *
 * Implementation of 3D geometry methods.  See geometry_3d.h
 */

// includes --------------------------------------------------------------------
#include "geometry_3d.h"                // always include our own header first

#include <math.h>

#include "util/parsing.h"
#include "util/token_stream.h"


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static void
getDictionaryFromLine
(
IO std::istream& stream,
IN const char * debug_info,
OUT dictionary_t& d
)
{
        ASSERT(stream.good(), "bad?");
        ASSERT(debug_info, "null");

        eParseBehavior behavior = (eParseBehavior)
            (eParse_StripComments | eParse_StripBogus);

        std::string line = getNextLineFromStream(stream, behavior);

        getDictionaryFromString(line.c_str(), debug_info, d);
}



static float
getOptionalFloat
(
IN const dictionary_t& d,
IN const char * key
)
{
        ASSERT(key, "null");

        return atof(getOptionalValue(d, key, "0"));
}



void
parsePointFromDictionary
(
IN const dictionary_t& d,
OUT point3d_t& p
)
{
        p.x = getOptionalFloat(d, "x");
        p.y = getOptionalFloat(d, "y");
        p.z = getOptionalFloat(d, "z");
}



void
parseRectFromDictionary
(
IN const dictionary_t& d,
OUT rect3d_t& rect
)
{
        rect.x0 = getOptionalFloat(d, "x0");
        rect.x1 = getOptionalFloat(d, "x1");
        rect.y0 = getOptionalFloat(d, "y0");
        rect.y1 = getOptionalFloat(d, "y1");
        rect.z0 = getOptionalFloat(d, "z0");
        rect.z1 = getOptionalFloat(d, "z1");
}


////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

point3d_t
rect3d_t::getCorner
(
IN int index
)
const
throw()
{
        ASSERT(index >= 0 && index < eMaxCorners,
            "Bad rectangle corner index: %d", index);

        point3d_t retval;
        retval.x = (index % 2) ? x0 : x1;
        index /= 2;
        retval.y = (index % 2) ? y0 : y1;
        index /= 2;
        retval.z = (index % 2) ? z0 : z1;

        return retval;
}



void
rect3d_t::getEdge
(
IN int index,
OUT point3d_t& p0,
OUT point3d_t& p1
)
const
throw()
{
        switch (index) {
        case 0:
                p0 = this->getCorner(0);
                p1 = this->getCorner(1);
                return;

        case 1:
                p0 = this->getCorner(0);
                p1 = this->getCorner(2);
                return;

        case 2:
                p0 = this->getCorner(0);
                p1 = this->getCorner(4);
                return;

        case 3:
                p0 = this->getCorner(1);
                p1 = this->getCorner(3);
                return;

        case 4:
                p0 = this->getCorner(1);
                p1 = this->getCorner(5);
                return;

        case 5:
                p0 = this->getCorner(2);
                p1 = this->getCorner(3);
                return;

        case 6:
                p0 = this->getCorner(2);
                p1 = this->getCorner(6);
                return;

        case 7:
                p0 = this->getCorner(3);
                p1 = this->getCorner(7);
                return;

        case 8:
                p0 = this->getCorner(4);
                p1 = this->getCorner(5);
                return;

        case 9:
                p0 = this->getCorner(4);
                p1 = this->getCorner(6);
                return;

        case 10:
                p0 = this->getCorner(5);
                p1 = this->getCorner(7);
                return;

        case 11:
                p0 = this->getCorner(6);
                p1 = this->getCorner(7);
                return;
        }

        ASSERT(index >= 0 && index <= eMaxEdges,
            "Bad rectangle edge index: %d", index);
        ASSERT(false, "should never get here");
}



point3d_t
operator *
(
IN const point3d_t& p,
IN float r
)
throw()
{
        point3d_t x = p;
        x.scale(r);
        return x;
}



const vector3d_t&
normalize
(
IO vector3d_t& v
)
throw()
{
        float sum = v.x * v.x + v.y * v.y + v.z * v.z;
        if (0 == sum)
                return v;

        sum = 1.0 / sqrt(sum);
        v.x *= sum;
        v.y *= sum;
        v.z *= sum;

        return v;
}



point3d_t
readPoint
(
IN std::istream& stream
)
{
        point3d_t p;
        std::string token;

        expectToken(stream, "{");
        expectToken(stream, "x");
        p.x = readFloat(stream, token);
        expectToken(stream, "y");
        p.y = readFloat(stream, token);
        expectToken(stream, "z");
        p.z = readFloat(stream, token);
        expectToken(stream, "}");

        return p;
}



rect3d_t
readRect
(
IN std::istream& stream
)
{
        rect3d_t r;
        std::string token;

        expectToken(stream, "{");
        expectToken(stream, "x0");
        r.x0 = readFloat(stream, token);
        expectToken(stream, "x1");
        r.x1 = readFloat(stream, token);
        expectToken(stream, "y0");
        r.y0 = readFloat(stream, token);
        expectToken(stream, "y1");
        r.y1 = readFloat(stream, token);
        expectToken(stream, "z0");
        r.z0 = readFloat(stream, token);
        expectToken(stream, "z1");
        r.z1 = readFloat(stream, token);
        expectToken(stream, "}");

        return r;
}



void
parsePoint3d
(
IO std::istream& stream,
OUT point3d_t& p
)
{
        ASSERT(stream.good(), "bad?");

        dictionary_t d;
        getDictionaryFromLine(stream, "3D point", d);
//      DPRINTF("Point dictionary:");
//      for (Dictionary::iterator i = d.begin(); i != d.end(); ++i) {
//              DPRINTF("  '%s' = '%s'", i->first.c_str(), i->second.c_str());
//      }
        parsePointFromDictionary(d, p);
}



void
parseRect3d
(
IO std::istream& stream,
OUT rect3d_t& rect
)
{
        ASSERT(stream.good(), "bad?");

        dictionary_t d;
        getDictionaryFromLine(stream, "3D rectangle", d);
        parseRectFromDictionary(d, rect);
}



void
parsePoint3d
(
IN const char * string,
OUT point3d_t& p
)
{
        ASSERT(string, "null");

        dictionary_t d;
        getDictionaryFromString(string, "3D point", d);
        parsePointFromDictionary(d, p);
}



void
parseRect3d
(
IN const char * string,
OUT rect3d_t& r
)
{
        ASSERT(string, "null");

        dictionary_t d;
        getDictionaryFromString(string, "3D rectangle", d);
        parseRectFromDictionary(d, r);
}