CompositeBox.h

//===========================================================================
// GoTools - SINTEF Geometry Tools version 1.1
//
// GoTools module: CORE
//
// Copyright (C) 2000-2007 SINTEF ICT, Applied Mathematics, Norway.
//
// This program is free software; you can redistribute it and/or          
// modify it under the terms of the GNU General Public License            
// as published by the Free Software Foundation version 2 of the License. 
//
// This program 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 General Public License for more details.                           
//
// You should have received a copy of the GNU General Public License      
// along with this program; if not, write to the Free Software            
// Foundation, Inc.,                                                      
// 59 Temple Place - Suite 330,                                           
// Boston, MA  02111-1307, USA.                                           
//
// Contact information: E-mail: tor.dokken@sintef.no                      
// SINTEF ICT, Department of Applied Mathematics,                         
// P.O. Box 124 Blindern,                                                 
// 0314 Oslo, Norway.                                                     
//
// Other licenses are also available for this software, notably licenses
// for:
// - Building commercial software.                                        
// - Building software whose source code you wish to keep private.        
//===========================================================================
#ifndef _COMPOSITEBOX_H
#define _COMPOSITEBOX_H

#include "BoundingBox.h"

namespace Go
{



class CompositeBox
{
public:
    template <typename RandomAccessIterator>
    CompositeBox(RandomAccessIterator start,
                 int dim,
                 int num_u,
                 int num_v)
    {
        obsolete_inner_ = 0;
        setFromArray(start, dim, num_u, num_v);
    }
    CompositeBox(const Point& low, const Point& high)
        : inner_(low, high), edge_(low, high), obsolete_inner_(0)
    {
    }
    ~CompositeBox();

    void setFromPoints(const Point& low, const Point& high)
    {
        inner_.setFromPoints(low, high);
        edge_ = inner_;
        obsolete_inner_ = 0;
    }

    template <typename RandomAccessIterator>
    void setFromArray(RandomAccessIterator start,
                      int dim,
                      int num_u,
                      int num_v)
    {
        if (num_u < 3 || num_v == 2) {
            // We cannot make a separate inner box. Just make
            // two identical boxes. The num_v == 1 case is the curve
            // special case, which is handled.
            edge_.setFromArray(start, start+dim*num_u*num_v, dim);
            Point mid = 0.5*(edge_.low() + edge_.high());
            inner_.setFromPoints(mid, mid);
            obsolete_inner_ = 0;
            return;
        }
        // First do the inner box.
        int vstart = (num_v == 1) ? 0 : 1;
        int vend = (num_v == 1) ? num_v : num_v - 1;
        Point il(start + dim*(1 + num_u*vstart),
                 start + dim*(2 + num_u*vstart));
        Point ih(il);
        for (int i = vstart; i < vend; ++i) {
            for (int j = 1; j < num_u-1; ++j) {
                RandomAccessIterator pnt = start + dim*(j + num_u*i);
                for (int d = 0; d < dim; ++d) {
                    if (pnt[d] < il[d]) {
                        il[d] = pnt[d];
                    } else if (pnt[d] > ih[d]) {
                        ih[d] = pnt[d];
                    }
                }
            }
        }
        inner_.setFromPoints(il, ih);

        // Then the edge box.
        Point el(start, start+dim);
        Point eh(el);
        if (num_v == 1) {
            // We have a curve. Only check the endpoint
            RandomAccessIterator pnt = start + dim*(num_u - 1);
            for (int d = 0; d < dim; ++d) {
                if (pnt[d] < el[d]) {
                    el[d] = pnt[d];
                } else if (pnt[d] > eh[d]) {
                    eh[d] = pnt[d];
                }
            }
        } else {
            // We have a 2D-array, check all boundary points
            for (int i = 0; i < num_v; ++i) {
                for (int j = 0; j < num_u; j += num_u-1) {
                    RandomAccessIterator pnt = start + dim*(j + num_u*i);
                    for (int d = 0; d < dim; ++d) {
                        if (pnt[d] < el[d]) {
                            el[d] = pnt[d];
                        } else if (pnt[d] > eh[d]) {
                            eh[d] = pnt[d];
                        }
                    }
                }
            }
            for (int j = 0; j < num_u; ++j) {
                for (int i = 0; i < num_v; i += num_v-1) {
                    RandomAccessIterator pnt = start + dim*(j + num_u*i);
                    for (int d = 0; d < dim; ++d) {
                        if (pnt[d] < el[d]) {
                            el[d] = pnt[d];
                        } else if (pnt[d] > eh[d]) {
                            eh[d] = pnt[d];
                        }
                    }
                }
            }
        }
        edge_.setFromPoints(el, eh);
    }

    void read(std::istream& is);
    void write(std::ostream& os) const;

    int  dimension()  const
    {
        return inner_.dimension();
    }

    Point low(double toli = 0.0,
              double tole = 0.0) const;


    Point high(double toli = 0.0,
               double tole = 0.0) const;


    const BoundingBox& inner() const
    {
        return inner_;
    }
    const BoundingBox& edge() const
    {
        return edge_;
    }

    bool containsPoint(const Point& pt,
                       double toli = 0.0,
                       double tole = 0.0) const;

    bool overlaps(const CompositeBox& box,
                  double toli = 0.0,
                  double tole = 0.0) const;

    bool getOverlap(const CompositeBox& box,
                  double& overlap,
                  double toli = 0.0,
                  double tole = 0.0) const;

    bool containsBox(const CompositeBox& box,
                     double toli = 0.0,
                     double tole = 0.0) const;


private:
    // Data members
    BoundingBox inner_;
    BoundingBox edge_;
    int obsolete_inner_;
};

} // namespace Go


#endif // _COMPOSITEBOX_H

---