BBoxList.h

Go to the documentation of this file.

// -*- C++ -*-

#ifndef _included_BBoxList_h
#define _included_BBoxList_h

#include "DAGHDefaults.h"

#include "BucketType.h"
#include "BBox.h"
#include "Coords.h"
#include "ObjectCounter.h"

#include <iosfwd>
#include <cstdlib>

#ifndef DefBBoxListSize
#define DefBBoxListSize              (128)
#endif

class BBoxList : public Bucket<BBox>, public ObjectCounter
{
public:
    /*************************************************************************/
    /*** Constructors ***/
    /*************************************************************************/
    inline BBoxList()
        : Bucket<BBox>(DefBBoxListSize) {}

    // Mark as explicit to avoid implicit conversions to this class
    explicit BBoxList(const unsigned int maxnum) 
        : Bucket<BBox>(maxnum) {}

    inline BBoxList(const void *package, const unsigned int size, const int n)
        : Bucket<BBox>(package, size, n) {}

    inline BBoxList(const BBoxList &other)
        : Bucket<BBox>(other) {}

    BBoxList& operator=(const BBoxList&);

    /*************************************************************************/
    /*** Destructor ***/
    /*************************************************************************/
    inline ~BBoxList(void) {}

    /*************************************************************************/
    /*** For the object counter ***/
    /*************************************************************************/
    inline BBoxList* alias()
        { return dynamic_cast<BBoxList*>(ObjectCounter::alias()); }

    /*************************************************************************/
    /* BBoxList operators */
    /*************************************************************************/
    int difference(BBoxList& bbl, const BBox& lhs, const BBox& rhs);
    int intersection(BBoxList& bbl, const BBox& lhs, const BBox& rhs);
    void operator -= (const BBoxList &rhs); /* Difference */
    void operator -= (const BBox &rhs); 
    void operator *= (const BBoxList &rhs); /* Intersection */
    void operator *= (const BBox &rhs); 

private:
    /*************************************************************************/
    /* Nest with another list - This needs work */
    /*************************************************************************/
    void nest(const BBoxList &rhs);

public:
    /*************************************************************************/
    /* Merge bounding boxes in the list is possible */
    /*************************************************************************/
    void mergeboxes(const short* olap);

    /*************************************************************************/
    /* Combine two bbl's */
    /*************************************************************************/
    void combine(const BBoxList &rhs);
   
    /*************************************************************************/
    /* Reduce the list in a single bounding box */
    /*************************************************************************/
    BBox reduce();
};

// i/o functions
std::ostream& operator<<(std::ostream&, const BBoxList&);
std::ofstream& operator<<(std::ofstream&, const BBoxList&);
std::ifstream& operator>>(std::ifstream&, BBoxList&);
std::stringstream& operator<<(std::stringstream&, const BBoxList&);
std::stringstream& operator>>(std::stringstream&, BBoxList&);

/*************************************************************************/
/* interface routines */
/*************************************************************************/
inline BBox* first(BBoxList &bbl) { return bbl.first(); }
inline BBox* last(BBoxList &bbl) { return bbl.last(); }
inline BBox* next(BBoxList &bbl) { return bbl.next(); }
inline BBox* prev(BBoxList &bbl) { return bbl.prev(); }
inline BBox* current(BBoxList &bbl) { return bbl.current(); }

inline void add(BBoxList &bbl, const BBox &bb) { bbl.add(bb); }
inline void insert(BBoxList &bbl, const BBox &bb) { bbl.insert(bb); }
inline void remove(BBoxList &bbl) { bbl.remove(); }

inline int number(const BBoxList &bbl) { return bbl.number(); }
inline bool isempty(const BBoxList &bbl) { return bbl.isempty(); }

inline void empty(BBoxList &bbl) { bbl.empty(); }

#endif

---