BaseCore.h

Go to the documentation of this file.

// -*- lsst-c++ -*-

/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 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_ELLIPSES_BaseCore_h_INCLUDED
#define LSST_AFW_GEOM_ELLIPSES_BaseCore_h_INCLUDED

#include "boost/shared_ptr.hpp"
#include "boost/make_shared.hpp"
#include <memory>
#include "Eigen/Core"

#include "lsst/pex/exceptions.h"
#include "lsst/afw/geom/LinearTransform.h"

namespace lsst { namespace afw { namespace geom { namespace ellipses {

class Parametric;

class BaseCore {
public:
#ifndef SWIG
    class Transformer;
    class GridTransform;
    class Convolution;
    template <typename Output> struct Converter;
#endif

    typedef boost::shared_ptr<BaseCore> Ptr;
    typedef boost::shared_ptr<BaseCore const> ConstPtr;

    typedef Eigen::Vector3d ParameterVector;  
    typedef Eigen::Matrix3d Jacobian; 

    static Ptr make(std::string const & name);

    static Ptr make(std::string const & name, ParameterVector const & parameters);

    static Ptr make(std::string const & name, double v1, double v2, double v3);

    static Ptr make(std::string const & name, BaseCore const & other);

#ifndef SWIG
    static Ptr make(std::string const & name, Transformer const & other);

    static Ptr make(std::string const & name, Convolution const & other);
#endif

    virtual std::string getName() const = 0;

    Ptr clone() const { return _clone(); }

    virtual void normalize() = 0;

    void grow(double buffer);

    void scale(double factor);

    double getArea() const;

    double getDeterminantRadius() const;
    
    double getTraceRadius() const;

    Transformer transform(LinearTransform const & transform);
    Transformer const transform(LinearTransform const & transform) const;

    GridTransform const getGridTransform() const;

    Convolution convolve(BaseCore const & other);
    Convolution const convolve(BaseCore const & other) const;

    Extent2D computeDimensions() const;

    virtual void readParameters(double const * iter) = 0;

    virtual void writeParameters(double * iter) const = 0;

    ParameterVector const getParameterVector() const;

    void setParameterVector(ParameterVector const & vector);

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

    bool operator!=(BaseCore const & other) const { return !operator==(other); }

    BaseCore & operator=(BaseCore const & other);

    Jacobian dAssign(BaseCore const & other);

    template <typename Output> Converter<Output> as() const;

    virtual ~BaseCore() {}

protected:
#ifndef SWIG
    friend class Parametric;

    static void registerSubclass(Ptr const & example);

    template <typename T>
    struct Registrar {
        Registrar() { registerSubclass(boost::make_shared<T>()); }
    };

    virtual BaseCore::Ptr _clone() const = 0;

    static void _assignQuadrupoleToAxes(
        double ixx, double iyy, double ixy, 
        double & a, double & b, double & theta
    );

    static Jacobian _dAssignQuadrupoleToAxes(
        double ixx, double iyy, double ixy, 
        double & a, double & b, double & theta
    );

    static void _assignAxesToQuadrupole(
        double a, double b, double theta,
        double & ixx, double & iyy, double & ixy
    );

    static Jacobian _dAssignAxesToQuadrupole(
        double a, double b, double theta,
        double & ixx, double & iyy, double & ixy
    );

    virtual void _assignToQuadrupole(double & ixx, double & iyy, double & ixy) const = 0;
    virtual void _assignFromQuadrupole(double ixx, double iyy, double ixy) = 0;

    virtual void _assignToAxes(double & a, double & b, double & theta) const = 0;
    virtual void _assignFromAxes(double a, double b, double theta) = 0;

    virtual Jacobian _dAssignToQuadrupole(double & ixx, double & iyy, double & ixy) const = 0;
    virtual Jacobian _dAssignFromQuadrupole(double ixx, double iyy, double ixy) = 0;

    virtual Jacobian _dAssignToAxes(double & a, double & b, double & theta) const = 0;
    virtual Jacobian _dAssignFromAxes(double a, double b, double theta) = 0;

#endif
};

#ifndef SWIG
template <typename Output>
struct BaseCore::Converter {
    BaseCore const & input;

    explicit Converter(BaseCore const & input_) : input(input_) {}

    operator Output() const { return Output(input); }
    boost::shared_ptr<Output> copy() const { return boost::shared_ptr<Output>(new Output(input)); }
};

template <typename Output>
inline BaseCore::Converter<Output> BaseCore::as() const {
    return Converter<Output>(*this);
}

#endif

}}}} // namespace lsst::afw::geom::ellipses

#endif // !LSST_AFW_GEOM_ELLIPSES_BaseCore_h_INCLUDED