UT/UT_BoundingRect.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Cristin Barghiel
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:
 *      This file contains auxiliary classes for the Geometry Library
 *
 *
 */

#ifndef __UT_BoundingRect_H__
#define __UT_BoundingRect_H__

#include "UT_API.h"
#include <iostream.h>
#include <SYS/SYS_Types.h>
#include "UT_Assert.h"

class UT_Vector2;

class UT_API UT_BoundingRect {
public:
                UT_BoundingRect() {}
                UT_BoundingRect(fpreal xmin,fpreal ymin, fpreal xmax,fpreal ymax)
                {
                    vals[0][0] = xmin; vals[1][0] = ymin;
                    vals[0][1] = xmax; vals[1][1] = ymax;
                }

                UT_BoundingRect(const UT_Vector2 &lowerbound,
                                const UT_Vector2 &upperbound);

    float        operator()(unsigned m, unsigned n) const
                 {
                     UT_ASSERT_P( m < 2 && n < 2 );
                     return vals[m][n];
                 }
    float       &operator()(unsigned m, unsigned n)
                 {
                     UT_ASSERT_P( m < 2 && n < 2 );
                     return vals[m][n];
                 }

    int          operator==(const UT_BoundingRect &brect) const
                 {
                    return (vals[0][0] == brect.vals[0][0] &&
                            vals[0][1] == brect.vals[0][1] &&
                            vals[1][0] == brect.vals[1][0] &&
                            vals[1][1] == brect.vals[1][1] );
                 }

    int         contains(const UT_Vector2 &pt) const;
    int         contains(const UT_Vector2 &pt, fpreal tol) const;
    int         contains(fpreal x, fpreal y) const
                {
                    return (x >= vals[0][0] && x <= vals[0][1] &&
                            y >= vals[1][0] && y <= vals[1][1] );
                }

    int         isInside(const UT_BoundingRect &brect) const
                {
                    // are we inside brect?
                    return (vals[0][0] >= brect.vals[0][0] &&
                            vals[0][1] <= brect.vals[0][1] &&
                            vals[1][0] >= brect.vals[1][0] &&
                            vals[1][1] <= brect.vals[1][1] );
                }

    // Determine whether a line between v0 & v1 intersects the rect
    int         intersects(const UT_Vector2 &v0, const UT_Vector2 &v1) const;
    int         intersects(const UT_BoundingRect &rect) const;
    int         intersects(const UT_BoundingRect &rect, fpreal tol) const;

    void        initBounds(const UT_Vector2 &pt);
    void        initBounds(fpreal x, fpreal y)
                {
                    vals[0][0] = vals[0][1] = x;
                    vals[1][0] = vals[1][1] = y;
                }
    void        initBounds(fpreal xmin, fpreal xmax, fpreal ymin, fpreal ymax)
                {
                    vals[0][0] = xmin; vals[0][1] = xmax;
                    vals[1][0] = ymin; vals[1][1] = ymax;
                }
    void        initBounds(const UT_BoundingRect &rect)
                {
                    vals[0][0] = rect.vals[0][0];
                    vals[0][1] = rect.vals[0][1];
                    vals[1][0] = rect.vals[1][0];
                    vals[1][1] = rect.vals[1][1];
                }

    void        enlargeBounds(const UT_Vector2 &pt);
    void        enlargeBounds(fpreal x, fpreal y)
                {
                         if (x < vals[0][0]) vals[0][0] = x;
                    else if (x > vals[0][1]) vals[0][1] = x;
                         if (y < vals[1][0]) vals[1][0] = y;
                    else if (y > vals[1][1]) vals[1][1] = y;
                }
    void        enlargeBounds(fpreal xmin, fpreal xmax, fpreal ymin, fpreal ymax)
                {
                    if (xmin < vals[0][0]) vals[0][0] = xmin;
                    if (xmax > vals[0][1]) vals[0][1] = xmax;
                    if (ymin < vals[1][0]) vals[1][0] = ymin;
                    if (ymax > vals[1][1]) vals[1][1] = ymax;
                }
    void        enlargeBounds(const UT_BoundingRect &rect)
                {
                    if (rect(0, 0) < vals[0][0]) vals[0][0] = rect(0, 0);
                    if (rect(0, 1) > vals[0][1]) vals[0][1] = rect(0, 1);
                    if (rect(1, 0) < vals[1][0]) vals[1][0] = rect(1, 0);
                    if (rect(1, 1) > vals[1][1]) vals[1][1] = rect(1, 1);
                }
    void        stretch(fpreal percent = 0.001F, fpreal min = 0.001F)
                {
                    fpreal d;
                    d = min + (vals[0][1] - vals[0][0])*percent;
                    vals[0][0] -= d; vals[0][1] += d;
                    d = min + (vals[1][1] - vals[1][0])*percent;
                    vals[1][0] -= d; vals[1][1] += d;
                }
    void        translate(fpreal x, fpreal y)
                {
                    vals[0][0] += x;
                    vals[0][1] += x;
                    vals[1][0] += y;
                    vals[1][1] += y;
                }

    fpreal      sizeX() const { return vals[0][1] - vals[0][0]; }
    fpreal      sizeY() const { return vals[1][1] - vals[1][0]; }

    fpreal      centerX() const { return (vals[0][0] + vals[0][1]) * .5f; }
    fpreal      centerY() const { return (vals[1][0] + vals[1][1]) * .5f; }

    // projects (x,y) orthogonally to the closest point on the rectangle.
    // Result is stored back into x and y.  If valid addresses are passed into
    // touchx and touchy, then, the values in those addresses would indicate
    // if the new (x,y) now touches the x edges or y edges of the rectangle.
    void        project(float &x, float &y, int *touchx=0, int *touchy=0) const;

    fpreal      LX() const      { return vals[0][0]; }
    fpreal      LY() const      { return vals[1][0]; }
    fpreal      UX() const      { return vals[0][1]; }
    fpreal      UY() const      { return vals[1][1]; }

    float       &LX()           { return vals[0][0]; }
    float       &LY()           { return vals[1][0]; }
    float       &UX()           { return vals[0][1]; }
    float       &UY()           { return vals[1][1]; }

//
// Intersect a ray with the rect.  Returns 0 if no intersection found.
// distance will be set to the intersection distance (between 0 & tmax)
//
    int         intersectRay(const UT_Vector2 &orig, const UT_Vector2 &dir,
                            fpreal      tmax      = 1E17F,
                            float       *distance = 0,
                            UT_Vector2  *xsect    = 0) const;

    // I/O methods:
    void        save(ostream &os, int binary = 0) const;

    // I/O friends:
    friend ostream      &operator<<(ostream &os, const UT_BoundingRect &brect)
                        {
                            brect.save(os);
                            return os;
                        }
    float       vals[2][2];
private:
};

#endif

---