ShapeUtilities.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * LSST Data Management System
 * Copyright 2008-2015 AURA/LSST.
 *
 * 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_MEAS_BASE_ShapeUtilities_h_INCLUDED
#define LSST_MEAS_BASE_ShapeUtilities_h_INCLUDED

#include "lsst/meas/base/constants.h"
#include "lsst/afw/table/aggregates.h"

namespace lsst { namespace meas { namespace base {

struct ShapeResult {
    ShapeElement xx; // image or model second moment for x^2
    ShapeElement yy; // image or model second moment for y^2
    ShapeElement xy; // image or model second moment for xy^2
    ErrElement xxSigma; 
    ErrElement yySigma; 
    ErrElement xySigma; 
    ErrElement xx_yy_Cov; 
    ErrElement xx_xy_Cov; 
    ErrElement yy_xy_Cov; 

    ShapeResult();

    explicit ShapeResult(ShapeElement _xx, ShapeElement _yy, ShapeElement _xy, ShapeCov const & matrix):
        xx(_xx),
        yy(_yy),
        xy(_xy),
        xxSigma(std::sqrt(matrix(0, 0))),
        yySigma(std::sqrt(matrix(1, 1))),
        xySigma(std::sqrt(matrix(2, 2))),
        xx_yy_Cov(matrix(0, 1)),
        xx_xy_Cov(matrix(0, 2)),
        yy_xy_Cov(matrix(1, 2))
    {}

    explicit ShapeResult(ShapeElement _xx, ShapeElement _yy, ShapeElement _xy,
                            ErrElement _xxSigma, ErrElement _yySigma, ErrElement _xySigma) :
        xx(_xx),
        yy(_yy),
        xy(_xy),
        xxSigma(_xxSigma),
        yySigma(_yySigma),
        xySigma(_xySigma),
        xx_yy_Cov(0.0),
        xx_xy_Cov(0.0),
        yy_xy_Cov(0.0)
    {}

    Shape const getShape() const;

    // get the Quadrupole corresponding to this ShapeResult
    afw::geom::ellipses::Quadrupole getQuadrupole()
    {
        return afw::geom::ellipses::Quadrupole(xx, yy, xy);
    }

    void setShape(Shape const & shape);

    ShapeCov const getShapeErr() const;

    void setShapeErr(ShapeCov const & matrix);

    void setShapeErr(ErrElement _xxSigma, ErrElement _yySigma, ErrElement _xySigma);

};

class ShapeResultKey : public afw::table::FunctorKey<ShapeResult>  {
public:

    static ShapeResultKey addFields(
        afw::table::Schema & schema,
        std::string const & name,
        std::string const & doc,
        UncertaintyEnum uncertainty,
        afw::table::CoordinateType coordType=afw::table::CoordinateType::PIXEL
    );

    ShapeResultKey() : _shape(), _shapeErr() {}

    ShapeResultKey(
        afw::table::QuadrupoleKey const & shape,
        afw::table::CovarianceMatrixKey<ErrElement,3> const & shapeErr
    ) :
        _shape(shape), _shapeErr(shapeErr)
    {}

    ShapeResultKey(afw::table::SubSchema const & s);

    virtual ShapeResult get(afw::table::BaseRecord const & record) const;

    virtual void set(afw::table::BaseRecord & record, ShapeResult const & value) const;

    bool operator==(ShapeResultKey const & other) const {
        return _shape == other._shape && _shapeErr == other._shapeErr;
    }
    bool operator!=(ShapeResultKey const & other) const { return !(*this == other); }

    bool isValid() const { return _shape.isValid() && _shapeErr.isValid(); }

    afw::table::QuadrupoleKey getShape() const { return _shape; }

    afw::table::CovarianceMatrixKey<ErrElement,3> getShapeErr() const { return _shapeErr; }

    afw::table::Key<ShapeElement> getIxx() const { return _shape.getIxx(); }

    afw::table::Key<ShapeElement> getIyy() const { return _shape.getIyy(); }

    afw::table::Key<ShapeElement> getIxy() const { return _shape.getIxy(); }

private:
    afw::table::QuadrupoleKey _shape;
    afw::table::CovarianceMatrixKey<ErrElement,3> _shapeErr;
};

ShapeTrMatrix makeShapeTransformMatrix(afw::geom::LinearTransform const & xform);

}}} // lsst::meas::base

#endif // !LSST_MEAS_BASE_ShapeUtilities_h_INCLUDED