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/geom/LinearTransform.h"
#include "lsst/afw/table/aggregates.h"
 
namespace lsst {
namespace meas {
namespace base {
 
struct ShapeResult {
    ShapeElement xx;       
    ShapeElement yy;       
    ShapeElement xy;       
    ErrElement xxErr;      
    ErrElement yyErr;      
    ErrElement xyErr;      
    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_),
              xxErr(std::sqrt(matrix(0, 0))),
              yyErr(std::sqrt(matrix(1, 1))),
              xyErr(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 xxErr_,
                         ErrElement yyErr_, ErrElement xyErr_)
            : xx(xx_),
              yy(yy_),
              xy(xy_),
              xxErr(xxErr_),
              yyErr(yyErr_),
              xyErr(xyErr_),
              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 xxErr, ErrElement yyErr, ErrElement xyErr);
};
 
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(geom::LinearTransform const& xform);
 
}  // namespace base
}  // namespace meas
}  // namespace lsst
 
#endif  // !LSST_MEAS_BASE_ShapeUtilities_h_INCLUDED