Domain.hpp

#ifndef DOMAIN_HPP
#define DOMAIN_HPP

#include <string>
#include <sstream>
#include <stdint.h>

#include "splash/Dimensions.hpp"

namespace splash
{

    class Domain
    {
    public:

        Domain() :
        offset(0, 0, 0),
        size(1, 1, 1)
        {

        }

        Domain(Dimensions offset_, Dimensions size_) :
        offset(offset_),
        size(size_)
        {

        }

        uint32_t getDims() const
        {
            return size.getDims();
        }

        Dimensions &getSize()
        {
            return size;
        }

        const Dimensions getSize() const
        {
            return size;
        }

        Dimensions &getOffset()
        {
            return offset;
        }

        const Dimensions getOffset() const
        {
            return offset;
        }

        Dimensions getBack() const
        {
            return offset + size - Dimensions(1, 1, 1);
        }

        bool operator==(Domain const& other) const
        {
            return offset == other.getOffset() && size == other.getSize();
        }

        bool operator!=(Domain const& other) const
        {
            return !(*this == other);
        }

        std::string toString() const
        {
            std::stringstream stream;
            stream << "(offset: " << offset.toString() << ", size: " << size.toString() << ")";
            return stream.str();
        }

        static bool testIntersection(const Domain& d1, const Domain& d2)
        {
            Dimensions d1_offset = d1.getOffset();
            Dimensions d2_offset = d2.getOffset();
            Dimensions d1_end = d1.getBack();
            Dimensions d2_end = d2.getBack();

            return (d1_offset[0] <= d2_end[0] && d1_end[0] >= d2_offset[0] &&
                    d1_offset[1] <= d2_end[1] && d1_end[1] >= d2_offset[1] &&
                    d1_offset[2] <= d2_end[2] && d1_end[2] >= d2_offset[2]) ||
                    (d2_offset[0] <= d1_end[0] && d2_end[0] >= d1_offset[0] &&
                    d2_offset[1] <= d1_end[1] && d2_end[1] >= d1_offset[1] &&
                    d2_offset[2] <= d1_end[2] && d2_end[2] >= d1_offset[2]);
        }

    protected:
        Dimensions offset;
        Dimensions size;
    };

}

#endif /* DOMAIN_HPP */