Polygon.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/>.
 */

#if !defined(LSST_AFW_GEOM_POLYGON_POLYGON_H)
#define LSST_AFW_GEOM_POLYGON_POLYGON_H

#include <vector>
#include <utility> // for std::pair

#include "boost/make_shared.hpp"

#include "lsst/base.h"
#include "lsst/pex/exceptions.h"
#include "lsst/afw/geom/Box.h"
#include "lsst/afw/geom/Point.h"
#include "lsst/afw/geom/AffineTransform.h"
#include "lsst/afw/geom/XYTransform.h"
#include "lsst/afw/image/Image.h"
#include "lsst/afw/image/MaskedImage.h"

namespace lsst { namespace afw { namespace geom { namespace polygon {

LSST_EXCEPTION_TYPE(SinglePolygonException, lsst::pex::exceptions::RuntimeError,
                    lsst::afw::geom::polygon::SinglePolygonException);


class Polygon: public afw::table::io::PersistableFacade<Polygon>, public afw::table::io::Persistable {
public:
    typedef Box2D Box;
    typedef Point2D Point;

    explicit Polygon(Box const& box);
    Polygon(Box const& box,             
            CONST_PTR(XYTransform) const& transform 
        );
    Polygon(Box const& box,                  
            AffineTransform const& transform 
        );
    explicit Polygon(std::vector<Point> const& vertices);


    void swap(Polygon& other) {
        std::swap(this->_impl, other._impl);
    }

    size_t getNumEdges() const;

    Box getBBox() const;

    Point calculateCenter() const;
    double calculateArea() const;
    double calculatePerimeter() const;

    std::vector<Point> getVertices() const;

    std::vector<Point>::const_iterator begin() const;
    std::vector<Point>::const_iterator end() const;

    std::vector<std::pair<Point, Point> > getEdges() const;

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

    bool contains(Point const& point) const;

    bool overlaps(Polygon const& other) const;
    bool overlaps(Box const& box) const;

    PTR(Polygon) intersectionSingle(Polygon const& other) const;
    PTR(Polygon) intersectionSingle(Box const& box) const;

    std::vector<PTR(Polygon)> intersection(Polygon const& other) const;
    std::vector<PTR(Polygon)> intersection(Box const& box) const;

    PTR(Polygon) unionSingle(Polygon const& other) const;
    PTR(Polygon) unionSingle(Box const& box) const;

    std::vector<PTR(Polygon)> union_(Polygon const& other) const;
    std::vector<PTR(Polygon)> union_(Box const& box) const;

    std::vector<PTR(Polygon)> symDifference(Polygon const& other) const;
    std::vector<PTR(Polygon)> symDifference(Box const& box) const;

    PTR(Polygon) simplify(double const distance) const;

    std::vector<PTR(Polygon)> operator&(Polygon const& rhs) const { return intersection(rhs); }
    std::vector<PTR(Polygon)> operator&(Box const& rhs) const { return intersection(rhs); }
    std::vector<PTR(Polygon)> operator|(Polygon const& rhs) const { return union_(rhs); }
    std::vector<PTR(Polygon)> operator|(Box const& rhs) const { return union_(rhs); }
    std::vector<PTR(Polygon)> operator^(Polygon const& rhs) const { return symDifference(rhs); }
    std::vector<PTR(Polygon)> operator^(Box const& rhs) const { return symDifference(rhs); }

    PTR(Polygon) convexHull() const;

    PTR(Polygon) transform(
        CONST_PTR(XYTransform) const& transform 
        ) const;
    PTR(Polygon) transform(
        AffineTransform const& transform 
        ) const;

    PTR(Polygon) subSample(size_t num) const;
    PTR(Polygon) subSample(double maxLength) const;

    PTR(afw::image::Image<float>) createImage(Box2I const& bbox) const;
    PTR(afw::image::Image<float>) createImage(Extent2I const& extent) const {
        return createImage(Box2I(Point2I(0, 0), extent));
    }

    virtual bool isPersistable() const { return true; }

protected:

    virtual std::string getPersistenceName() const;

    virtual void write(OutputArchiveHandle & handle) const;

private:
    struct Impl;
    PTR(Impl) _impl;
    Polygon(PTR(Impl) impl) : _impl(impl) {}
};

std::ostream& operator<<(std::ostream& os, Polygon const& poly);

}}}} // namespace lsst::afw::geom::polygon

#endif