RStarBoundingBox< dimensions > Struct Template Reference

#include <RStarBoundingBox.h>

Public Member Functions
void	reset ()
bool	stretch (const RStarBoundingBox< dimensions > &bb)
int	edgeDeltas () const
double	area () const
bool	encloses (const RStarBoundingBox< dimensions > &bb) const
bool	overlaps (const RStarBoundingBox< dimensions > &bb) const
double	overlap (const RStarBoundingBox< dimensions > &bb) const
double	distanceFromCenter (const RStarBoundingBox< dimensions > &bb) const
bool	operator== (const RStarBoundingBox< dimensions > &bb)
std::string	ToString () const

Static Public Member Functions
static RStarBoundingBox	MaximumBounds ()

Public Attributes
std::pair< double, double >	edges [dimensions]

Detailed Description

template<std::size_t dimensions>
struct RStarBoundingBox< dimensions >

Definition at line 30 of file RStarBoundingBox.h.

Member Function Documentation

template<std::size_t dimensions>

double RStarBoundingBox< dimensions >::area ( ) const

inline

Definition at line 89 of file RStarBoundingBox.h.

        {
                double area = 1;
                for (std::size_t axis = 0; axis < dimensions; axis++)
                        area *= (double)(edges[axis].second - edges[axis].first);

                return area;
        }

template<std::size_t dimensions>

double RStarBoundingBox< dimensions >::distanceFromCenter ( const RStarBoundingBox< dimensions > &  bb ) const

inline

Definition at line 170 of file RStarBoundingBox.h.

        {
                double distance = 0, t;
                for (std::size_t axis = 0; axis < dimensions; axis++)
                {
                        t = ((double)edges[axis].first + (double)edges[axis].second +
                             (double)bb.edges[axis].first + (double)bb.edges[axis].second)
                                 /2.0;
                        distance += t*t;
                }

                return distance;
        }

template<std::size_t dimensions>

int RStarBoundingBox< dimensions >::edgeDeltas ( ) const

inline

Definition at line 79 of file RStarBoundingBox.h.

        {
                double distance = 0;
                for (std::size_t axis = 0; axis < dimensions; axis++)
                        distance += edges[axis].second - edges[axis].first;

                return distance;
        }

template<std::size_t dimensions>

bool RStarBoundingBox< dimensions >::encloses ( const RStarBoundingBox< dimensions > &  bb ) const

inline

Definition at line 99 of file RStarBoundingBox.h.

        {
                // if (y1 < x1 || x2 < y2)
                for (std::size_t axis = 0; axis < dimensions; axis++)
                        if (bb.edges[axis].first < edges[axis].first || edges[axis].second < bb.edges[axis].second)
                                return false;

                return true;
        }

template<std::size_t dimensions>

static RStarBoundingBox RStarBoundingBox< dimensions >::MaximumBounds ( )

inlinestatic

Definition at line 46 of file RStarBoundingBox.h.

        {
                RStarBoundingBox<dimensions> bound;
                bound.reset();
                return bound;
        }

template<std::size_t dimensions>

bool RStarBoundingBox< dimensions >::operator== ( const RStarBoundingBox< dimensions > &  bb )

inline

Definition at line 185 of file RStarBoundingBox.h.

        {
                for (std::size_t axis = 0; axis < dimensions; axis++)
                        if (edges[axis].first != bb.edges[axis].first || edges[axis].second != bb.edges[axis].second)
                                return false;

                return true;
        }

template<std::size_t dimensions>

double RStarBoundingBox< dimensions >::overlap ( const RStarBoundingBox< dimensions > &  bb ) const

inline

Definition at line 124 of file RStarBoundingBox.h.

        {
                double area = 1.0;
                for (std::size_t axis = 0; area && axis < dimensions; axis++)
                {
                        // this makes it easier to understand
                        const double x1 = edges[axis].first;
                        const double x2 = edges[axis].second;
                        const double y1 = bb.edges[axis].first;
                        const double y2 = bb.edges[axis].second;

                        // left edge outside left edge
                        if (x1 < y1)
                        {
                                // and right edge inside left edge
                                if (y1 < x2)
                                {
                                        // right edge outside right edge
                                        if (y2 < x2)
                                                area *= (double)( y2 - y1 );
                                        else
                                                area *= (double)( x2 - y1 );

                                        continue;
                                }
                        }
                        // right edge inside left edge
                        else if (x1 < y2)
                        {
                                // right edge outside right edge
                                if (x2 < y2)
                                        area *= (double)( x2 - x1 );
                                else
                                        area *= (double)( y2 - x1 );

                                continue;
                        }

                        // if we get here, there is no overlap
                        return 0.0;
                }

                return area;
        }

template<std::size_t dimensions>

bool RStarBoundingBox< dimensions >::overlaps ( const RStarBoundingBox< dimensions > &  bb ) const

inline

Definition at line 110 of file RStarBoundingBox.h.

        {
                // do it this way so theres no equal signs (in case of doubles)
                // if (!(x1 < y2) && !(x2 > y1))
                for (std::size_t axis = 0; axis < dimensions; axis++)
                {
                        if (!(edges[axis].first < bb.edges[axis].second) || !(bb.edges[axis].first < edges[axis].second))
                                return false;
                }

                return true;
        }

template<std::size_t dimensions>

void RStarBoundingBox< dimensions >::reset ( )

inline

Definition at line 36 of file RStarBoundingBox.h.

        {
                for (std::size_t axis = 0; axis < dimensions; axis++)
                {
                        edges[axis].first = std::numeric_limits<double>::max();
                        edges[axis].second = std::numeric_limits<double>::min();
                }
        }

template<std::size_t dimensions>

bool RStarBoundingBox< dimensions >::stretch ( const RStarBoundingBox< dimensions > &  bb )

inline

Definition at line 55 of file RStarBoundingBox.h.

        {
                bool ret = false;

                for (std::size_t axis = 0; axis < dimensions; axis++)
                {

                        if (edges[axis].first > bb.edges[axis].first)
                        {
                                edges[axis].first = bb.edges[axis].first;
                                ret = true;
                        }

                        if (edges[axis].second < bb.edges[axis].second)
                        {
                                edges[axis].second = bb.edges[axis].second;
                                ret = true;
                        }
                }

                return ret;
        }

template<std::size_t dimensions>

std::string RStarBoundingBox< dimensions >::ToString ( ) const

inline

Definition at line 196 of file RStarBoundingBox.h.

        {
                std::stringstream name("");
                name << "[";
                for (std::size_t axis = 0; axis < dimensions; axis++)
                {
                        name << "(" << edges[axis].first << "," << edges[axis].second << ")";
                        if (axis != dimensions -1)
                                name << ",";
                }
                name << "]";

                return name.str();
        }

Member Data Documentation

template<std::size_t dimensions>

std::pair<double, double> RStarBoundingBox< dimensions >::edges[dimensions]

Definition at line 33 of file RStarBoundingBox.h.

---

The documentation for this struct was generated from the following file:

• larreco/larreco/ClusterFinder/RStarTree/RStarBoundingBox.h