Box.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * LSST Data Management System
 * Copyright 2008-2014 LSST Corporation.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * 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, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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 LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */

#ifndef LSST_AFW_GEOM_BOX_H
#define LSST_AFW_GEOM_BOX_H

#include <vector>
#include "boost/format.hpp"
#include "lsst/afw/geom/Point.h"
#include "lsst/afw/geom/Extent.h"
#include "ndarray.h"

namespace lsst { namespace afw { namespace geom {

class Box2D;

class Box2I {
public:

    typedef Point2I Point;
    typedef Extent2I Extent;

    enum EdgeHandlingEnum { EXPAND, SHRINK };

    Box2I() : _minimum(0), _dimensions(0) {}

    Box2I(Point2I const & minimum, Point2I const & maximum, bool invert=true);

    Box2I(Point2I const & minimum, Extent2I const & dimensions, bool invert=true);


    explicit Box2I(Box2D const & other, EdgeHandlingEnum edgeHandling=EXPAND);

    Box2I(Box2I const & other) : _minimum(other._minimum), _dimensions(other._dimensions) {}

    void swap(Box2I & other) {
        _minimum.swap(other._minimum);
        _dimensions.swap(other._dimensions);
    }

    Box2I & operator=(Box2I const & other) {
        _minimum = other._minimum;
        _dimensions = other._dimensions;
        return *this;
    }

    Point2I const getMin() const { return _minimum; }
    int getMinX() const { return _minimum.getX(); }
    int getMinY() const { return _minimum.getY(); }

    Point2I const getMax() const { return _minimum + _dimensions - Extent2I(1); }
    int getMaxX() const { return _minimum.getX() + _dimensions.getX() - 1; }
    int getMaxY() const { return _minimum.getY() + _dimensions.getY() - 1; }

    Point2I const getBegin() const { return _minimum; }
    int getBeginX() const { return _minimum.getX(); }
    int getBeginY() const { return _minimum.getY(); }

    Point2I const getEnd() const { return _minimum + _dimensions; }
    int getEndX() const { return _minimum.getX() + _dimensions.getX(); }
    int getEndY() const { return _minimum.getY() + _dimensions.getY(); }

    Extent2I const getDimensions() const { return _dimensions; }
    int getWidth() const { return _dimensions.getX(); }
    int getHeight() const { return _dimensions.getY(); }
    int getArea() const { return getWidth() * getHeight(); }

    ndarray::View<
        boost::fusion::vector2< ndarray::index::Range, ndarray::index::Range >
        >
    getSlices() const;

    bool isEmpty() const {
        return _dimensions.getX() == 0 && _dimensions.getY() == 0;
    }

    bool contains(Point2I const & point) const;

    bool contains(Box2I const & other) const;

    bool overlaps(Box2I const & other) const;

    void grow(int buffer) { grow(Extent2I(buffer)); }

    void grow(Extent2I const & buffer);

    void shift(Extent2I const & offset);

    void flipLR(int xExtent);

    void flipTB(int yExtent);

    void include(Point2I const & point);

    void include(Box2I const & other);

    void clip(Box2I const & other);

    bool operator==(Box2I const & other) const;

    bool operator!=(Box2I const & other) const;

    std::vector<Point2I> getCorners() const;

    std::string toString() const {
        return (boost::format("Box2I(%s,%s)") % _minimum.toString() % _dimensions.toString()).str();
    }

private:
    Point2I _minimum;
    Extent2I _dimensions;
};

class Box2D {
public:

    typedef Point2D Point;
    typedef Extent2D Extent;

    static double const EPSILON;

    static double const INVALID;

    Box2D();

    Box2D(Point2D const & minimum, Point2D const & maximum, bool invert=true);

    Box2D(Point2D const & minimum, Extent2D const & dimensions, bool invert=true);

    explicit Box2D(Box2I const & other);

    Box2D(Box2D const & other) : _minimum(other._minimum), _maximum(other._maximum) {}

    void swap(Box2D & other) {
        _minimum.swap(other._minimum);
        _maximum.swap(other._maximum);
    }

    Box2D & operator=(Box2D const & other) {
        _minimum = other._minimum;
        _maximum = other._maximum;
        return *this;
    }

    Point2D const getMin() const { return _minimum; }
    double getMinX() const { return _minimum.getX(); }
    double getMinY() const { return _minimum.getY(); }

    Point2D const getMax() const { return _maximum; }
    double getMaxX() const { return _maximum.getX(); }
    double getMaxY() const { return _maximum.getY(); }

    Extent2D const getDimensions() const { return isEmpty() ? Extent2D(0.0) : _maximum - _minimum; }
    double getWidth() const { return isEmpty() ? 0 : _maximum.getX() - _minimum.getX(); }
    double getHeight() const { return isEmpty() ? 0 : _maximum.getY() - _minimum.getY(); }
    double getArea() const {
        Extent2D dim(getDimensions());
        return dim.getX() * dim.getY();
    }

    Point2D const getCenter() const { return Point2D((_minimum.asEigen() + _maximum.asEigen())*0.5); }
    double getCenterX() const { return (_minimum.getX() + _maximum.getX())*0.5; }
    double getCenterY() const { return (_minimum.getY() + _maximum.getY())*0.5; }

    bool isEmpty() const { return _minimum.getX() != _minimum.getX(); }

    bool contains(Point2D const & point) const;

    bool contains(Box2D const & other) const;

    bool overlaps(Box2D const & other) const;

    void grow(double buffer) { grow(Extent2D(buffer)); }

    void grow(Extent2D const & buffer);

    void shift(Extent2D const & offset);

    void flipLR(float xExtent);

    void flipTB(float yExtent);

    void include(Point2D const & point);

    void include(Box2D const & other);

    void clip(Box2D const & other);

    bool operator==(Box2D const & other) const;

    bool operator!=(Box2D const & other) const;

    std::vector<Point2D> getCorners() const;

    std::string toString() const {
        return (boost::format("Box2D(%s,%s)") % _minimum.toString() % _maximum.toString()).str();
    }

private:
    void _tweakMax(int n) {
        if (_maximum[n] < 0.0) {
            _maximum[n] *= (1.0 - EPSILON);
        } else if (_maximum[n] > 0.0) {
            _maximum[n] *= (1.0 + EPSILON);
        } else {
            _maximum[n] = EPSILON;
        }
    }
    Point2D _minimum;
    Point2D _maximum;
};

typedef Box2D BoxD;
typedef Box2I BoxI;

std::ostream & operator<<(std::ostream & os, Box2I const & box);

std::ostream & operator<<(std::ostream & os, Box2D const & box);

}}}

#endif