VRS - The Virtual Rendering System

version 3.3

bounds.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2007 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  is  distributed  in  the  hope
 * that  it will be useful, but  WITHOUT ANY WARRANTY; without even the implied
 * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE.  See  the
 * GNU Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: bounds.h 6436 2008-07-14 15:10:59Z Manuel_Wellmann $

#ifndef VRS_BOUNDS_H
#define VRS_BOUNDS_H

#include <vrs/matrix.h>
#include <vrs/serializationmanager.h>

namespace VRS {

class VRS_CORE_API Bounds {

public:
    Bounds();
    explicit Bounds(const Vector& point);
    Bounds(const Vector& llf, const Vector& urb);

    bool operator==(const Bounds&) const;

    bool operator!=(const Bounds&) const;

    void addPoint(const Vector& point);
    void addVolume(const Bounds& bound);
    Bounds& operator+=(const Vector& point);
    Bounds& operator+=(const Bounds& bound);
    Bounds operator+(const Vector& point) const;
    Bounds operator+(const Bounds& bound) const;

    Vector getLLF() const;
    Vector getURB() const;
    Vector point(double x, double y, double z) const;
    Vector center() const;

    Vector diagonal() const;
    double volume() const;

    bool isDefined() const;

    bool containsPoint(const Vector& p) const;
    bool containsPointInPlane(const Vector& p, unsigned int a = 0, unsigned int b = 1) const;
    bool containsVolume(const Bounds& b) const;
    bool intersects(const Bounds& b) const;
        bool intersectsInPlane(const Bounds& bounds, unsigned int a = 0, unsigned int b = 1) const;
    Bounds intersection(const Bounds& bounds) const;

    void transform(const Matrix& matrix);

    void expand(double factor);

    friend VRS_CORE_API std::ostream& operator<<(std::ostream&, const Bounds&);
    friend VRS_CORE_API std::istream& operator>>(std::istream&, Bounds&);

    // implement persistency
    VRS_SERIALIZABLE_NO_SO_CLASS(Bounds);

private:
    Vector llf_;
    Vector urb_;
};

inline Bounds::Bounds() : llf_(INF,INF,INF), urb_(-INF,-INF,-INF) { }
inline Bounds::Bounds(const Vector& point) : llf_(point), urb_(point) { }

inline bool Bounds::operator==(const Bounds& v) const { return llf_==v.llf_ && urb_==v.urb_; }
inline bool Bounds::operator!=(const Bounds& v) const { return llf_!=v.llf_ || urb_!=v.urb_; }

inline void Bounds::addVolume(const Bounds& v) { *this += v; }
inline void Bounds::addPoint(const Vector& v) { *this += v; }

inline Bounds Bounds::operator+(const Vector& point) const { Bounds res = *this; return(res += point); }
inline Bounds Bounds::operator+(const Bounds& bound) const { Bounds res = *this; return(res += bound); }

inline Bounds operator*(const Matrix& mat, const Bounds& bounds) { Bounds res = bounds; res.transform(mat); return res; }

inline Vector Bounds::getLLF() const { return llf_; }
inline Vector Bounds::getURB() const { return urb_; }

inline bool Bounds::isDefined() const {
    return llf_[0] <= urb_[0] && llf_[1] <= urb_[1] && llf_[2] <= urb_[2];
}

} // namespace VRS

#endif // VRS_BOUNDS_H

---

Generated on Fri May 18 06:00:13 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact